Domain Flow API

Auth

authChangePassword

Change password


/auth/change-password

Usage and SDK Samples

curl -X POST \
 \
 -H "Accept: application/json" \
 -H "Content-Type: application/json" \
 "https://api.domainflow.dev/api/v2/auth/change-password" \
 -d ''
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.AuthApi;

import java.io.File;
import java.util.*;

public class AuthApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure API key authorization: cookieAuth
        ApiKeyAuth cookieAuth = (ApiKeyAuth) defaultClient.getAuthentication("cookieAuth");
        cookieAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //cookieAuth.setApiKeyPrefix("Token");

        // Create an instance of the API class
        AuthApi apiInstance = new AuthApi();
        AuthChangePasswordRequest authChangePasswordRequest = ; // AuthChangePasswordRequest | 

        try {
            auth_logout_200_response result = apiInstance.authChangePassword(authChangePasswordRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AuthApi#authChangePassword");
            e.printStackTrace();
        }
    }
}
import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final AuthChangePasswordRequest authChangePasswordRequest = new AuthChangePasswordRequest(); // AuthChangePasswordRequest | 

try {
    final result = await api_instance.authChangePassword(authChangePasswordRequest);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->authChangePassword: $e\n');
}

import org.openapitools.client.api.AuthApi;

public class AuthApiExample {
    public static void main(String[] args) {
        AuthApi apiInstance = new AuthApi();
        AuthChangePasswordRequest authChangePasswordRequest = ; // AuthChangePasswordRequest | 

        try {
            auth_logout_200_response result = apiInstance.authChangePassword(authChangePasswordRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AuthApi#authChangePassword");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: cookieAuth)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"domainflow_session"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"domainflow_session"];


// Create an instance of the API class
AuthApi *apiInstance = [[AuthApi alloc] init];
AuthChangePasswordRequest *authChangePasswordRequest = ; // 

// Change password
[apiInstance authChangePasswordWith:authChangePasswordRequest
              completionHandler: ^(auth_logout_200_response output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var DomainFlowApi = require('domain_flow_api');
var defaultClient = DomainFlowApi.ApiClient.instance;

// Configure API key authorization: cookieAuth
var cookieAuth = defaultClient.authentications['cookieAuth'];
cookieAuth.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//cookieAuth.apiKeyPrefix['domainflow_session'] = "Token";

// Create an instance of the API class
var api = new DomainFlowApi.AuthApi()
var authChangePasswordRequest = ; // {AuthChangePasswordRequest} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.authChangePassword(authChangePasswordRequest, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class authChangePasswordExample
    {
        public void main()
        {
            // Configure API key authorization: cookieAuth
            Configuration.Default.ApiKey.Add("domainflow_session", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("domainflow_session", "Bearer");

            // Create an instance of the API class
            var apiInstance = new AuthApi();
            var authChangePasswordRequest = new AuthChangePasswordRequest(); // AuthChangePasswordRequest | 

            try {
                // Change password
                auth_logout_200_response result = apiInstance.authChangePassword(authChangePasswordRequest);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling AuthApi.authChangePassword: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure API key authorization: cookieAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('domainflow_session', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('domainflow_session', 'Bearer');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\AuthApi();
$authChangePasswordRequest = ; // AuthChangePasswordRequest | 

try {
    $result = $api_instance->authChangePassword($authChangePasswordRequest);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling AuthApi->authChangePassword: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::AuthApi;

# Configure API key authorization: cookieAuth
$WWW::OPenAPIClient::Configuration::api_key->{'domainflow_session'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'domainflow_session'} = "Bearer";

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::AuthApi->new();
my $authChangePasswordRequest = WWW::OPenAPIClient::Object::AuthChangePasswordRequest->new(); # AuthChangePasswordRequest | 

eval {
    my $result = $api_instance->authChangePassword(authChangePasswordRequest => $authChangePasswordRequest);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling AuthApi->authChangePassword: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure API key authorization: cookieAuth
openapi_client.configuration.api_key['domainflow_session'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['domainflow_session'] = 'Bearer'

# Create an instance of the API class
api_instance = openapi_client.AuthApi()
authChangePasswordRequest =  # AuthChangePasswordRequest | 

try:
    # Change password
    api_response = api_instance.auth_change_password(authChangePasswordRequest)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling AuthApi->authChangePassword: %s\n" % e)
extern crate AuthApi;

pub fn main() {
    let authChangePasswordRequest = ; // AuthChangePasswordRequest

    let mut context = AuthApi::Context::default();
    let result = client.authChangePassword(authChangePasswordRequest, &context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Body parameters
Name Description
authChangePasswordRequest *

Responses


authLogin

User login


/auth/login

Usage and SDK Samples

curl -X POST \
 \
 -H "Accept: application/json" \
 -H "Content-Type: application/json" \
 "https://api.domainflow.dev/api/v2/auth/login" \
 -d '{
  "password" : "password",
  "email" : "email"
}'
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.AuthApi;

import java.io.File;
import java.util.*;

public class AuthApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure API key authorization: cookieAuth
        ApiKeyAuth cookieAuth = (ApiKeyAuth) defaultClient.getAuthentication("cookieAuth");
        cookieAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //cookieAuth.setApiKeyPrefix("Token");

        // Create an instance of the API class
        AuthApi apiInstance = new AuthApi();
        LoginRequest loginRequest = ; // LoginRequest | 

        try {
            auth_login_200_response result = apiInstance.authLogin(loginRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AuthApi#authLogin");
            e.printStackTrace();
        }
    }
}
import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final LoginRequest loginRequest = new LoginRequest(); // LoginRequest | 

try {
    final result = await api_instance.authLogin(loginRequest);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->authLogin: $e\n');
}

import org.openapitools.client.api.AuthApi;

public class AuthApiExample {
    public static void main(String[] args) {
        AuthApi apiInstance = new AuthApi();
        LoginRequest loginRequest = ; // LoginRequest | 

        try {
            auth_login_200_response result = apiInstance.authLogin(loginRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AuthApi#authLogin");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: cookieAuth)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"domainflow_session"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"domainflow_session"];


// Create an instance of the API class
AuthApi *apiInstance = [[AuthApi alloc] init];
LoginRequest *loginRequest = ; // 

// User login
[apiInstance authLoginWith:loginRequest
              completionHandler: ^(auth_login_200_response output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var DomainFlowApi = require('domain_flow_api');
var defaultClient = DomainFlowApi.ApiClient.instance;

// Configure API key authorization: cookieAuth
var cookieAuth = defaultClient.authentications['cookieAuth'];
cookieAuth.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//cookieAuth.apiKeyPrefix['domainflow_session'] = "Token";

// Create an instance of the API class
var api = new DomainFlowApi.AuthApi()
var loginRequest = ; // {LoginRequest} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.authLogin(loginRequest, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class authLoginExample
    {
        public void main()
        {
            // Configure API key authorization: cookieAuth
            Configuration.Default.ApiKey.Add("domainflow_session", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("domainflow_session", "Bearer");

            // Create an instance of the API class
            var apiInstance = new AuthApi();
            var loginRequest = new LoginRequest(); // LoginRequest | 

            try {
                // User login
                auth_login_200_response result = apiInstance.authLogin(loginRequest);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling AuthApi.authLogin: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure API key authorization: cookieAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('domainflow_session', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('domainflow_session', 'Bearer');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\AuthApi();
$loginRequest = ; // LoginRequest | 

try {
    $result = $api_instance->authLogin($loginRequest);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling AuthApi->authLogin: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::AuthApi;

# Configure API key authorization: cookieAuth
$WWW::OPenAPIClient::Configuration::api_key->{'domainflow_session'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'domainflow_session'} = "Bearer";

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::AuthApi->new();
my $loginRequest = WWW::OPenAPIClient::Object::LoginRequest->new(); # LoginRequest | 

eval {
    my $result = $api_instance->authLogin(loginRequest => $loginRequest);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling AuthApi->authLogin: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure API key authorization: cookieAuth
openapi_client.configuration.api_key['domainflow_session'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['domainflow_session'] = 'Bearer'

# Create an instance of the API class
api_instance = openapi_client.AuthApi()
loginRequest =  # LoginRequest | 

try:
    # User login
    api_response = api_instance.auth_login(loginRequest)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling AuthApi->authLogin: %s\n" % e)
extern crate AuthApi;

pub fn main() {
    let loginRequest = ; // LoginRequest

    let mut context = AuthApi::Context::default();
    let result = client.authLogin(loginRequest, &context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Body parameters
Name Description
loginRequest *

Responses

Name Type Format Description
Retry-After Integer Seconds to wait before retrying


authLogout

User logout


/auth/logout

Usage and SDK Samples

curl -X POST \
 \
 -H "Accept: application/json" \
 "https://api.domainflow.dev/api/v2/auth/logout"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.AuthApi;

import java.io.File;
import java.util.*;

public class AuthApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure API key authorization: cookieAuth
        ApiKeyAuth cookieAuth = (ApiKeyAuth) defaultClient.getAuthentication("cookieAuth");
        cookieAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //cookieAuth.setApiKeyPrefix("Token");

        // Create an instance of the API class
        AuthApi apiInstance = new AuthApi();

        try {
            auth_logout_200_response result = apiInstance.authLogout();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AuthApi#authLogout");
            e.printStackTrace();
        }
    }
}
import 'package:openapi/api.dart';

final api_instance = DefaultApi();


try {
    final result = await api_instance.authLogout();
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->authLogout: $e\n');
}

import org.openapitools.client.api.AuthApi;

public class AuthApiExample {
    public static void main(String[] args) {
        AuthApi apiInstance = new AuthApi();

        try {
            auth_logout_200_response result = apiInstance.authLogout();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AuthApi#authLogout");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: cookieAuth)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"domainflow_session"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"domainflow_session"];


// Create an instance of the API class
AuthApi *apiInstance = [[AuthApi alloc] init];

// User logout
[apiInstance authLogoutWithCompletionHandler: 
              ^(auth_logout_200_response output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var DomainFlowApi = require('domain_flow_api');
var defaultClient = DomainFlowApi.ApiClient.instance;

// Configure API key authorization: cookieAuth
var cookieAuth = defaultClient.authentications['cookieAuth'];
cookieAuth.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//cookieAuth.apiKeyPrefix['domainflow_session'] = "Token";

// Create an instance of the API class
var api = new DomainFlowApi.AuthApi()
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.authLogout(callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class authLogoutExample
    {
        public void main()
        {
            // Configure API key authorization: cookieAuth
            Configuration.Default.ApiKey.Add("domainflow_session", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("domainflow_session", "Bearer");

            // Create an instance of the API class
            var apiInstance = new AuthApi();

            try {
                // User logout
                auth_logout_200_response result = apiInstance.authLogout();
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling AuthApi.authLogout: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure API key authorization: cookieAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('domainflow_session', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('domainflow_session', 'Bearer');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\AuthApi();

try {
    $result = $api_instance->authLogout();
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling AuthApi->authLogout: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::AuthApi;

# Configure API key authorization: cookieAuth
$WWW::OPenAPIClient::Configuration::api_key->{'domainflow_session'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'domainflow_session'} = "Bearer";

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::AuthApi->new();

eval {
    my $result = $api_instance->authLogout();
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling AuthApi->authLogout: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure API key authorization: cookieAuth
openapi_client.configuration.api_key['domainflow_session'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['domainflow_session'] = 'Bearer'

# Create an instance of the API class
api_instance = openapi_client.AuthApi()

try:
    # User logout
    api_response = api_instance.auth_logout()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling AuthApi->authLogout: %s\n" % e)
extern crate AuthApi;

pub fn main() {

    let mut context = AuthApi::Context::default();
    let result = client.authLogout(&context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Responses


authMe

Get current user


/auth/me

Usage and SDK Samples

curl -X GET \
 \
 -H "Accept: application/json" \
 "https://api.domainflow.dev/api/v2/auth/me"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.AuthApi;

import java.io.File;
import java.util.*;

public class AuthApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure API key authorization: cookieAuth
        ApiKeyAuth cookieAuth = (ApiKeyAuth) defaultClient.getAuthentication("cookieAuth");
        cookieAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //cookieAuth.setApiKeyPrefix("Token");

        // Create an instance of the API class
        AuthApi apiInstance = new AuthApi();

        try {
            auth_me_200_response result = apiInstance.authMe();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AuthApi#authMe");
            e.printStackTrace();
        }
    }
}
import 'package:openapi/api.dart';

final api_instance = DefaultApi();


try {
    final result = await api_instance.authMe();
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->authMe: $e\n');
}

import org.openapitools.client.api.AuthApi;

public class AuthApiExample {
    public static void main(String[] args) {
        AuthApi apiInstance = new AuthApi();

        try {
            auth_me_200_response result = apiInstance.authMe();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AuthApi#authMe");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: cookieAuth)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"domainflow_session"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"domainflow_session"];


// Create an instance of the API class
AuthApi *apiInstance = [[AuthApi alloc] init];

// Get current user
[apiInstance authMeWithCompletionHandler: 
              ^(auth_me_200_response output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var DomainFlowApi = require('domain_flow_api');
var defaultClient = DomainFlowApi.ApiClient.instance;

// Configure API key authorization: cookieAuth
var cookieAuth = defaultClient.authentications['cookieAuth'];
cookieAuth.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//cookieAuth.apiKeyPrefix['domainflow_session'] = "Token";

// Create an instance of the API class
var api = new DomainFlowApi.AuthApi()
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.authMe(callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class authMeExample
    {
        public void main()
        {
            // Configure API key authorization: cookieAuth
            Configuration.Default.ApiKey.Add("domainflow_session", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("domainflow_session", "Bearer");

            // Create an instance of the API class
            var apiInstance = new AuthApi();

            try {
                // Get current user
                auth_me_200_response result = apiInstance.authMe();
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling AuthApi.authMe: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure API key authorization: cookieAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('domainflow_session', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('domainflow_session', 'Bearer');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\AuthApi();

try {
    $result = $api_instance->authMe();
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling AuthApi->authMe: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::AuthApi;

# Configure API key authorization: cookieAuth
$WWW::OPenAPIClient::Configuration::api_key->{'domainflow_session'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'domainflow_session'} = "Bearer";

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::AuthApi->new();

eval {
    my $result = $api_instance->authMe();
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling AuthApi->authMe: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure API key authorization: cookieAuth
openapi_client.configuration.api_key['domainflow_session'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['domainflow_session'] = 'Bearer'

# Create an instance of the API class
api_instance = openapi_client.AuthApi()

try:
    # Get current user
    api_response = api_instance.auth_me()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling AuthApi->authMe: %s\n" % e)
extern crate AuthApi;

pub fn main() {

    let mut context = AuthApi::Context::default();
    let result = client.authMe(&context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Responses


authRefresh

Refresh session


/auth/refresh

Usage and SDK Samples

curl -X POST \
 \
 -H "Accept: application/json" \
 "https://api.domainflow.dev/api/v2/auth/refresh"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.AuthApi;

import java.io.File;
import java.util.*;

public class AuthApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure API key authorization: cookieAuth
        ApiKeyAuth cookieAuth = (ApiKeyAuth) defaultClient.getAuthentication("cookieAuth");
        cookieAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //cookieAuth.setApiKeyPrefix("Token");

        // Create an instance of the API class
        AuthApi apiInstance = new AuthApi();

        try {
            auth_login_200_response result = apiInstance.authRefresh();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AuthApi#authRefresh");
            e.printStackTrace();
        }
    }
}
import 'package:openapi/api.dart';

final api_instance = DefaultApi();


try {
    final result = await api_instance.authRefresh();
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->authRefresh: $e\n');
}

import org.openapitools.client.api.AuthApi;

public class AuthApiExample {
    public static void main(String[] args) {
        AuthApi apiInstance = new AuthApi();

        try {
            auth_login_200_response result = apiInstance.authRefresh();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AuthApi#authRefresh");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: cookieAuth)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"domainflow_session"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"domainflow_session"];


// Create an instance of the API class
AuthApi *apiInstance = [[AuthApi alloc] init];

// Refresh session
[apiInstance authRefreshWithCompletionHandler: 
              ^(auth_login_200_response output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var DomainFlowApi = require('domain_flow_api');
var defaultClient = DomainFlowApi.ApiClient.instance;

// Configure API key authorization: cookieAuth
var cookieAuth = defaultClient.authentications['cookieAuth'];
cookieAuth.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//cookieAuth.apiKeyPrefix['domainflow_session'] = "Token";

// Create an instance of the API class
var api = new DomainFlowApi.AuthApi()
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.authRefresh(callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class authRefreshExample
    {
        public void main()
        {
            // Configure API key authorization: cookieAuth
            Configuration.Default.ApiKey.Add("domainflow_session", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("domainflow_session", "Bearer");

            // Create an instance of the API class
            var apiInstance = new AuthApi();

            try {
                // Refresh session
                auth_login_200_response result = apiInstance.authRefresh();
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling AuthApi.authRefresh: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure API key authorization: cookieAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('domainflow_session', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('domainflow_session', 'Bearer');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\AuthApi();

try {
    $result = $api_instance->authRefresh();
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling AuthApi->authRefresh: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::AuthApi;

# Configure API key authorization: cookieAuth
$WWW::OPenAPIClient::Configuration::api_key->{'domainflow_session'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'domainflow_session'} = "Bearer";

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::AuthApi->new();

eval {
    my $result = $api_instance->authRefresh();
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling AuthApi->authRefresh: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure API key authorization: cookieAuth
openapi_client.configuration.api_key['domainflow_session'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['domainflow_session'] = 'Bearer'

# Create an instance of the API class
api_instance = openapi_client.AuthApi()

try:
    # Refresh session
    api_response = api_instance.auth_refresh()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling AuthApi->authRefresh: %s\n" % e)
extern crate AuthApi;

pub fn main() {

    let mut context = AuthApi::Context::default();
    let result = client.authRefresh(&context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Responses


Campaigns

allocateBulkResources

Allocate bulk operation resources


/campaigns/bulk/resources/allocate

Usage and SDK Samples

curl -X POST \
 \
 -H "Accept: application/json" \
 -H "Content-Type: application/json" \
 "https://api.domainflow.dev/api/v2/campaigns/bulk/resources/allocate" \
 -d '{
  "duration" : 48837,
  "resources" : {
    "memory" : 77,
    "cpu" : 6,
    "storage" : 596,
    "networkBandwidth" : 1474
  },
  "operationType" : "domain_generation",
  "priority" : "normal",
  "tags" : {
    "key" : "tags"
  }
}'
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.CampaignsApi;

import java.io.File;
import java.util.*;

public class CampaignsApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure API key authorization: cookieAuth
        ApiKeyAuth cookieAuth = (ApiKeyAuth) defaultClient.getAuthentication("cookieAuth");
        cookieAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //cookieAuth.setApiKeyPrefix("Token");

        // Create an instance of the API class
        CampaignsApi apiInstance = new CampaignsApi();
        BulkResourceAllocationRequest bulkResourceAllocationRequest = ; // BulkResourceAllocationRequest | 

        try {
            allocateBulkResources_200_response result = apiInstance.allocateBulkResources(bulkResourceAllocationRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling CampaignsApi#allocateBulkResources");
            e.printStackTrace();
        }
    }
}
import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final BulkResourceAllocationRequest bulkResourceAllocationRequest = new BulkResourceAllocationRequest(); // BulkResourceAllocationRequest | 

try {
    final result = await api_instance.allocateBulkResources(bulkResourceAllocationRequest);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->allocateBulkResources: $e\n');
}

import org.openapitools.client.api.CampaignsApi;

public class CampaignsApiExample {
    public static void main(String[] args) {
        CampaignsApi apiInstance = new CampaignsApi();
        BulkResourceAllocationRequest bulkResourceAllocationRequest = ; // BulkResourceAllocationRequest | 

        try {
            allocateBulkResources_200_response result = apiInstance.allocateBulkResources(bulkResourceAllocationRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling CampaignsApi#allocateBulkResources");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: cookieAuth)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"domainflow_session"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"domainflow_session"];


// Create an instance of the API class
CampaignsApi *apiInstance = [[CampaignsApi alloc] init];
BulkResourceAllocationRequest *bulkResourceAllocationRequest = ; // 

// Allocate bulk operation resources
[apiInstance allocateBulkResourcesWith:bulkResourceAllocationRequest
              completionHandler: ^(allocateBulkResources_200_response output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var DomainFlowApi = require('domain_flow_api');
var defaultClient = DomainFlowApi.ApiClient.instance;

// Configure API key authorization: cookieAuth
var cookieAuth = defaultClient.authentications['cookieAuth'];
cookieAuth.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//cookieAuth.apiKeyPrefix['domainflow_session'] = "Token";

// Create an instance of the API class
var api = new DomainFlowApi.CampaignsApi()
var bulkResourceAllocationRequest = ; // {BulkResourceAllocationRequest} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.allocateBulkResources(bulkResourceAllocationRequest, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class allocateBulkResourcesExample
    {
        public void main()
        {
            // Configure API key authorization: cookieAuth
            Configuration.Default.ApiKey.Add("domainflow_session", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("domainflow_session", "Bearer");

            // Create an instance of the API class
            var apiInstance = new CampaignsApi();
            var bulkResourceAllocationRequest = new BulkResourceAllocationRequest(); // BulkResourceAllocationRequest | 

            try {
                // Allocate bulk operation resources
                allocateBulkResources_200_response result = apiInstance.allocateBulkResources(bulkResourceAllocationRequest);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling CampaignsApi.allocateBulkResources: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure API key authorization: cookieAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('domainflow_session', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('domainflow_session', 'Bearer');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\CampaignsApi();
$bulkResourceAllocationRequest = ; // BulkResourceAllocationRequest | 

try {
    $result = $api_instance->allocateBulkResources($bulkResourceAllocationRequest);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling CampaignsApi->allocateBulkResources: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::CampaignsApi;

# Configure API key authorization: cookieAuth
$WWW::OPenAPIClient::Configuration::api_key->{'domainflow_session'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'domainflow_session'} = "Bearer";

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::CampaignsApi->new();
my $bulkResourceAllocationRequest = WWW::OPenAPIClient::Object::BulkResourceAllocationRequest->new(); # BulkResourceAllocationRequest | 

eval {
    my $result = $api_instance->allocateBulkResources(bulkResourceAllocationRequest => $bulkResourceAllocationRequest);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling CampaignsApi->allocateBulkResources: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure API key authorization: cookieAuth
openapi_client.configuration.api_key['domainflow_session'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['domainflow_session'] = 'Bearer'

# Create an instance of the API class
api_instance = openapi_client.CampaignsApi()
bulkResourceAllocationRequest =  # BulkResourceAllocationRequest | 

try:
    # Allocate bulk operation resources
    api_response = api_instance.allocate_bulk_resources(bulkResourceAllocationRequest)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling CampaignsApi->allocateBulkResources: %s\n" % e)
extern crate CampaignsApi;

pub fn main() {
    let bulkResourceAllocationRequest = ; // BulkResourceAllocationRequest

    let mut context = CampaignsApi::Context::default();
    let result = client.allocateBulkResources(bulkResourceAllocationRequest, &context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Body parameters
Name Description
bulkResourceAllocationRequest *

Responses

Name Type Format Description
Retry-After Integer Seconds to wait before retrying


bulkAnalyzeDomains

Bulk domain analysis


/campaigns/bulk/domains/analyze

Usage and SDK Samples

curl -X POST \
 \
 -H "Accept: application/json" \
 -H "Content-Type: application/json" \
 "https://api.domainflow.dev/api/v2/campaigns/bulk/domains/analyze" \
 -d '{
  "granularity" : "day",
  "aggregation" : {
    "functions" : [ "sum", "sum" ],
    "groupBy" : [ "groupBy", "groupBy" ]
  },
  "campaignIds" : [ "046b6c7f-0b8a-43b9-b35d-6489e6daee91", "046b6c7f-0b8a-43b9-b35d-6489e6daee91", "046b6c7f-0b8a-43b9-b35d-6489e6daee91", "046b6c7f-0b8a-43b9-b35d-6489e6daee91", "046b6c7f-0b8a-43b9-b35d-6489e6daee91" ],
  "metrics" : [ "response_time", "response_time" ],
  "timeRange" : {
    "timezone" : "UTC",
    "startTime" : "2000-01-23T04:56:07.000+00:00",
    "endTime" : "2000-01-23T04:56:07.000+00:00"
  }
}'
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.CampaignsApi;

import java.io.File;
import java.util.*;

public class CampaignsApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure API key authorization: cookieAuth
        ApiKeyAuth cookieAuth = (ApiKeyAuth) defaultClient.getAuthentication("cookieAuth");
        cookieAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //cookieAuth.setApiKeyPrefix("Token");

        // Create an instance of the API class
        CampaignsApi apiInstance = new CampaignsApi();
        BulkAnalyticsRequest bulkAnalyticsRequest = ; // BulkAnalyticsRequest | 

        try {
            bulkAnalyzeDomains_200_response result = apiInstance.bulkAnalyzeDomains(bulkAnalyticsRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling CampaignsApi#bulkAnalyzeDomains");
            e.printStackTrace();
        }
    }
}
import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final BulkAnalyticsRequest bulkAnalyticsRequest = new BulkAnalyticsRequest(); // BulkAnalyticsRequest | 

try {
    final result = await api_instance.bulkAnalyzeDomains(bulkAnalyticsRequest);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->bulkAnalyzeDomains: $e\n');
}

import org.openapitools.client.api.CampaignsApi;

public class CampaignsApiExample {
    public static void main(String[] args) {
        CampaignsApi apiInstance = new CampaignsApi();
        BulkAnalyticsRequest bulkAnalyticsRequest = ; // BulkAnalyticsRequest | 

        try {
            bulkAnalyzeDomains_200_response result = apiInstance.bulkAnalyzeDomains(bulkAnalyticsRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling CampaignsApi#bulkAnalyzeDomains");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: cookieAuth)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"domainflow_session"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"domainflow_session"];


// Create an instance of the API class
CampaignsApi *apiInstance = [[CampaignsApi alloc] init];
BulkAnalyticsRequest *bulkAnalyticsRequest = ; // 

// Bulk domain analysis
[apiInstance bulkAnalyzeDomainsWith:bulkAnalyticsRequest
              completionHandler: ^(bulkAnalyzeDomains_200_response output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var DomainFlowApi = require('domain_flow_api');
var defaultClient = DomainFlowApi.ApiClient.instance;

// Configure API key authorization: cookieAuth
var cookieAuth = defaultClient.authentications['cookieAuth'];
cookieAuth.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//cookieAuth.apiKeyPrefix['domainflow_session'] = "Token";

// Create an instance of the API class
var api = new DomainFlowApi.CampaignsApi()
var bulkAnalyticsRequest = ; // {BulkAnalyticsRequest} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.bulkAnalyzeDomains(bulkAnalyticsRequest, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class bulkAnalyzeDomainsExample
    {
        public void main()
        {
            // Configure API key authorization: cookieAuth
            Configuration.Default.ApiKey.Add("domainflow_session", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("domainflow_session", "Bearer");

            // Create an instance of the API class
            var apiInstance = new CampaignsApi();
            var bulkAnalyticsRequest = new BulkAnalyticsRequest(); // BulkAnalyticsRequest | 

            try {
                // Bulk domain analysis
                bulkAnalyzeDomains_200_response result = apiInstance.bulkAnalyzeDomains(bulkAnalyticsRequest);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling CampaignsApi.bulkAnalyzeDomains: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure API key authorization: cookieAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('domainflow_session', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('domainflow_session', 'Bearer');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\CampaignsApi();
$bulkAnalyticsRequest = ; // BulkAnalyticsRequest | 

try {
    $result = $api_instance->bulkAnalyzeDomains($bulkAnalyticsRequest);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling CampaignsApi->bulkAnalyzeDomains: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::CampaignsApi;

# Configure API key authorization: cookieAuth
$WWW::OPenAPIClient::Configuration::api_key->{'domainflow_session'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'domainflow_session'} = "Bearer";

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::CampaignsApi->new();
my $bulkAnalyticsRequest = WWW::OPenAPIClient::Object::BulkAnalyticsRequest->new(); # BulkAnalyticsRequest | 

eval {
    my $result = $api_instance->bulkAnalyzeDomains(bulkAnalyticsRequest => $bulkAnalyticsRequest);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling CampaignsApi->bulkAnalyzeDomains: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure API key authorization: cookieAuth
openapi_client.configuration.api_key['domainflow_session'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['domainflow_session'] = 'Bearer'

# Create an instance of the API class
api_instance = openapi_client.CampaignsApi()
bulkAnalyticsRequest =  # BulkAnalyticsRequest | 

try:
    # Bulk domain analysis
    api_response = api_instance.bulk_analyze_domains(bulkAnalyticsRequest)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling CampaignsApi->bulkAnalyzeDomains: %s\n" % e)
extern crate CampaignsApi;

pub fn main() {
    let bulkAnalyticsRequest = ; // BulkAnalyticsRequest

    let mut context = CampaignsApi::Context::default();
    let result = client.bulkAnalyzeDomains(bulkAnalyticsRequest, &context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Body parameters
Name Description
bulkAnalyticsRequest *

Responses

Name Type Format Description
Retry-After Integer Seconds to wait before retrying


bulkGenerateDomains

Bulk domain generation


/campaigns/bulk/domains/generate

Usage and SDK Samples

curl -X POST \
 \
 -H "Accept: application/json" \
 -H "Content-Type: application/json" \
 "https://api.domainflow.dev/api/v2/campaigns/bulk/domains/generate" \
 -d '{
  "operations" : [ {
    "maxDomains" : 596213,
    "campaignId" : "046b6c7f-0b8a-43b9-b35d-6489e6daee91",
    "config" : {
      "tlds" : [ "tlds", "tlds" ],
      "characterSet" : "characterSet",
      "variableLength" : 2,
      "numDomainsToGenerate" : 602746,
      "patternType" : "prefix",
      "constantString" : "constantString",
      "batchSize" : 1466
    }
  }, {
    "maxDomains" : 596213,
    "campaignId" : "046b6c7f-0b8a-43b9-b35d-6489e6daee91",
    "config" : {
      "tlds" : [ "tlds", "tlds" ],
      "characterSet" : "characterSet",
      "variableLength" : 2,
      "numDomainsToGenerate" : 602746,
      "patternType" : "prefix",
      "constantString" : "constantString",
      "batchSize" : 1466
    }
  }, {
    "maxDomains" : 596213,
    "campaignId" : "046b6c7f-0b8a-43b9-b35d-6489e6daee91",
    "config" : {
      "tlds" : [ "tlds", "tlds" ],
      "characterSet" : "characterSet",
      "variableLength" : 2,
      "numDomainsToGenerate" : 602746,
      "patternType" : "prefix",
      "constantString" : "constantString",
      "batchSize" : 1466
    }
  }, {
    "maxDomains" : 596213,
    "campaignId" : "046b6c7f-0b8a-43b9-b35d-6489e6daee91",
    "config" : {
      "tlds" : [ "tlds", "tlds" ],
      "characterSet" : "characterSet",
      "variableLength" : 2,
      "numDomainsToGenerate" : 602746,
      "patternType" : "prefix",
      "constantString" : "constantString",
      "batchSize" : 1466
    }
  }, {
    "maxDomains" : 596213,
    "campaignId" : "046b6c7f-0b8a-43b9-b35d-6489e6daee91",
    "config" : {
      "tlds" : [ "tlds", "tlds" ],
      "characterSet" : "characterSet",
      "variableLength" : 2,
      "numDomainsToGenerate" : 602746,
      "patternType" : "prefix",
      "constantString" : "constantString",
      "batchSize" : 1466
    }
  } ],
  "parallel" : true,
  "batchSize" : 5637
}'
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.CampaignsApi;

import java.io.File;
import java.util.*;

public class CampaignsApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure API key authorization: cookieAuth
        ApiKeyAuth cookieAuth = (ApiKeyAuth) defaultClient.getAuthentication("cookieAuth");
        cookieAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //cookieAuth.setApiKeyPrefix("Token");

        // Create an instance of the API class
        CampaignsApi apiInstance = new CampaignsApi();
        BulkDomainGenerationRequest bulkDomainGenerationRequest = ; // BulkDomainGenerationRequest | 

        try {
            bulkGenerateDomains_200_response result = apiInstance.bulkGenerateDomains(bulkDomainGenerationRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling CampaignsApi#bulkGenerateDomains");
            e.printStackTrace();
        }
    }
}
import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final BulkDomainGenerationRequest bulkDomainGenerationRequest = new BulkDomainGenerationRequest(); // BulkDomainGenerationRequest | 

try {
    final result = await api_instance.bulkGenerateDomains(bulkDomainGenerationRequest);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->bulkGenerateDomains: $e\n');
}

import org.openapitools.client.api.CampaignsApi;

public class CampaignsApiExample {
    public static void main(String[] args) {
        CampaignsApi apiInstance = new CampaignsApi();
        BulkDomainGenerationRequest bulkDomainGenerationRequest = ; // BulkDomainGenerationRequest | 

        try {
            bulkGenerateDomains_200_response result = apiInstance.bulkGenerateDomains(bulkDomainGenerationRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling CampaignsApi#bulkGenerateDomains");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: cookieAuth)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"domainflow_session"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"domainflow_session"];


// Create an instance of the API class
CampaignsApi *apiInstance = [[CampaignsApi alloc] init];
BulkDomainGenerationRequest *bulkDomainGenerationRequest = ; // 

// Bulk domain generation
[apiInstance bulkGenerateDomainsWith:bulkDomainGenerationRequest
              completionHandler: ^(bulkGenerateDomains_200_response output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var DomainFlowApi = require('domain_flow_api');
var defaultClient = DomainFlowApi.ApiClient.instance;

// Configure API key authorization: cookieAuth
var cookieAuth = defaultClient.authentications['cookieAuth'];
cookieAuth.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//cookieAuth.apiKeyPrefix['domainflow_session'] = "Token";

// Create an instance of the API class
var api = new DomainFlowApi.CampaignsApi()
var bulkDomainGenerationRequest = ; // {BulkDomainGenerationRequest} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.bulkGenerateDomains(bulkDomainGenerationRequest, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class bulkGenerateDomainsExample
    {
        public void main()
        {
            // Configure API key authorization: cookieAuth
            Configuration.Default.ApiKey.Add("domainflow_session", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("domainflow_session", "Bearer");

            // Create an instance of the API class
            var apiInstance = new CampaignsApi();
            var bulkDomainGenerationRequest = new BulkDomainGenerationRequest(); // BulkDomainGenerationRequest | 

            try {
                // Bulk domain generation
                bulkGenerateDomains_200_response result = apiInstance.bulkGenerateDomains(bulkDomainGenerationRequest);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling CampaignsApi.bulkGenerateDomains: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure API key authorization: cookieAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('domainflow_session', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('domainflow_session', 'Bearer');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\CampaignsApi();
$bulkDomainGenerationRequest = ; // BulkDomainGenerationRequest | 

try {
    $result = $api_instance->bulkGenerateDomains($bulkDomainGenerationRequest);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling CampaignsApi->bulkGenerateDomains: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::CampaignsApi;

# Configure API key authorization: cookieAuth
$WWW::OPenAPIClient::Configuration::api_key->{'domainflow_session'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'domainflow_session'} = "Bearer";

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::CampaignsApi->new();
my $bulkDomainGenerationRequest = WWW::OPenAPIClient::Object::BulkDomainGenerationRequest->new(); # BulkDomainGenerationRequest | 

eval {
    my $result = $api_instance->bulkGenerateDomains(bulkDomainGenerationRequest => $bulkDomainGenerationRequest);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling CampaignsApi->bulkGenerateDomains: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure API key authorization: cookieAuth
openapi_client.configuration.api_key['domainflow_session'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['domainflow_session'] = 'Bearer'

# Create an instance of the API class
api_instance = openapi_client.CampaignsApi()
bulkDomainGenerationRequest =  # BulkDomainGenerationRequest | 

try:
    # Bulk domain generation
    api_response = api_instance.bulk_generate_domains(bulkDomainGenerationRequest)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling CampaignsApi->bulkGenerateDomains: %s\n" % e)
extern crate CampaignsApi;

pub fn main() {
    let bulkDomainGenerationRequest = ; // BulkDomainGenerationRequest

    let mut context = CampaignsApi::Context::default();
    let result = client.bulkGenerateDomains(bulkDomainGenerationRequest, &context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Body parameters
Name Description
bulkDomainGenerationRequest *

Responses

Name Type Format Description
Retry-After Integer Seconds to wait before retrying


bulkValidateDNS

Bulk DNS validation


/campaigns/bulk/domains/validate-dns

Usage and SDK Samples

curl -X POST \
 \
 -H "Accept: application/json" \
 -H "Content-Type: application/json" \
 "https://api.domainflow.dev/api/v2/campaigns/bulk/domains/validate-dns" \
 -d '{
  "operations" : [ {
    "maxDomains" : 801,
    "personaIds" : [ "046b6c7f-0b8a-43b9-b35d-6489e6daee91", "046b6c7f-0b8a-43b9-b35d-6489e6daee91" ],
    "campaignId" : "046b6c7f-0b8a-43b9-b35d-6489e6daee91",
    "validationConfig" : {
      "retries" : 0,
      "recordTypes" : [ "A", "A" ],
      "timeout" : 18479
    }
  }, {
    "maxDomains" : 801,
    "personaIds" : [ "046b6c7f-0b8a-43b9-b35d-6489e6daee91", "046b6c7f-0b8a-43b9-b35d-6489e6daee91" ],
    "campaignId" : "046b6c7f-0b8a-43b9-b35d-6489e6daee91",
    "validationConfig" : {
      "retries" : 0,
      "recordTypes" : [ "A", "A" ],
      "timeout" : 18479
    }
  }, {
    "maxDomains" : 801,
    "personaIds" : [ "046b6c7f-0b8a-43b9-b35d-6489e6daee91", "046b6c7f-0b8a-43b9-b35d-6489e6daee91" ],
    "campaignId" : "046b6c7f-0b8a-43b9-b35d-6489e6daee91",
    "validationConfig" : {
      "retries" : 0,
      "recordTypes" : [ "A", "A" ],
      "timeout" : 18479
    }
  }, {
    "maxDomains" : 801,
    "personaIds" : [ "046b6c7f-0b8a-43b9-b35d-6489e6daee91", "046b6c7f-0b8a-43b9-b35d-6489e6daee91" ],
    "campaignId" : "046b6c7f-0b8a-43b9-b35d-6489e6daee91",
    "validationConfig" : {
      "retries" : 0,
      "recordTypes" : [ "A", "A" ],
      "timeout" : 18479
    }
  }, {
    "maxDomains" : 801,
    "personaIds" : [ "046b6c7f-0b8a-43b9-b35d-6489e6daee91", "046b6c7f-0b8a-43b9-b35d-6489e6daee91" ],
    "campaignId" : "046b6c7f-0b8a-43b9-b35d-6489e6daee91",
    "validationConfig" : {
      "retries" : 0,
      "recordTypes" : [ "A", "A" ],
      "timeout" : 18479
    }
  } ],
  "stealth" : {
    "delayRange" : {
      "min" : 5,
      "max" : 2
    },
    "enabled" : true,
    "randomizationLevel" : "medium"
  },
  "batchSize" : 596
}'
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.CampaignsApi;

import java.io.File;
import java.util.*;

public class CampaignsApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure API key authorization: cookieAuth
        ApiKeyAuth cookieAuth = (ApiKeyAuth) defaultClient.getAuthentication("cookieAuth");
        cookieAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //cookieAuth.setApiKeyPrefix("Token");

        // Create an instance of the API class
        CampaignsApi apiInstance = new CampaignsApi();
        BulkDNSValidationRequest bulkDNSValidationRequest = ; // BulkDNSValidationRequest | 

        try {
            bulkValidateDNS_200_response result = apiInstance.bulkValidateDNS(bulkDNSValidationRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling CampaignsApi#bulkValidateDNS");
            e.printStackTrace();
        }
    }
}
import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final BulkDNSValidationRequest bulkDNSValidationRequest = new BulkDNSValidationRequest(); // BulkDNSValidationRequest | 

try {
    final result = await api_instance.bulkValidateDNS(bulkDNSValidationRequest);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->bulkValidateDNS: $e\n');
}

import org.openapitools.client.api.CampaignsApi;

public class CampaignsApiExample {
    public static void main(String[] args) {
        CampaignsApi apiInstance = new CampaignsApi();
        BulkDNSValidationRequest bulkDNSValidationRequest = ; // BulkDNSValidationRequest | 

        try {
            bulkValidateDNS_200_response result = apiInstance.bulkValidateDNS(bulkDNSValidationRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling CampaignsApi#bulkValidateDNS");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: cookieAuth)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"domainflow_session"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"domainflow_session"];


// Create an instance of the API class
CampaignsApi *apiInstance = [[CampaignsApi alloc] init];
BulkDNSValidationRequest *bulkDNSValidationRequest = ; // 

// Bulk DNS validation
[apiInstance bulkValidateDNSWith:bulkDNSValidationRequest
              completionHandler: ^(bulkValidateDNS_200_response output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var DomainFlowApi = require('domain_flow_api');
var defaultClient = DomainFlowApi.ApiClient.instance;

// Configure API key authorization: cookieAuth
var cookieAuth = defaultClient.authentications['cookieAuth'];
cookieAuth.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//cookieAuth.apiKeyPrefix['domainflow_session'] = "Token";

// Create an instance of the API class
var api = new DomainFlowApi.CampaignsApi()
var bulkDNSValidationRequest = ; // {BulkDNSValidationRequest} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.bulkValidateDNS(bulkDNSValidationRequest, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class bulkValidateDNSExample
    {
        public void main()
        {
            // Configure API key authorization: cookieAuth
            Configuration.Default.ApiKey.Add("domainflow_session", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("domainflow_session", "Bearer");

            // Create an instance of the API class
            var apiInstance = new CampaignsApi();
            var bulkDNSValidationRequest = new BulkDNSValidationRequest(); // BulkDNSValidationRequest | 

            try {
                // Bulk DNS validation
                bulkValidateDNS_200_response result = apiInstance.bulkValidateDNS(bulkDNSValidationRequest);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling CampaignsApi.bulkValidateDNS: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure API key authorization: cookieAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('domainflow_session', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('domainflow_session', 'Bearer');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\CampaignsApi();
$bulkDNSValidationRequest = ; // BulkDNSValidationRequest | 

try {
    $result = $api_instance->bulkValidateDNS($bulkDNSValidationRequest);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling CampaignsApi->bulkValidateDNS: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::CampaignsApi;

# Configure API key authorization: cookieAuth
$WWW::OPenAPIClient::Configuration::api_key->{'domainflow_session'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'domainflow_session'} = "Bearer";

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::CampaignsApi->new();
my $bulkDNSValidationRequest = WWW::OPenAPIClient::Object::BulkDNSValidationRequest->new(); # BulkDNSValidationRequest | 

eval {
    my $result = $api_instance->bulkValidateDNS(bulkDNSValidationRequest => $bulkDNSValidationRequest);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling CampaignsApi->bulkValidateDNS: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure API key authorization: cookieAuth
openapi_client.configuration.api_key['domainflow_session'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['domainflow_session'] = 'Bearer'

# Create an instance of the API class
api_instance = openapi_client.CampaignsApi()
bulkDNSValidationRequest =  # BulkDNSValidationRequest | 

try:
    # Bulk DNS validation
    api_response = api_instance.bulk_validate_dns(bulkDNSValidationRequest)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling CampaignsApi->bulkValidateDNS: %s\n" % e)
extern crate CampaignsApi;

pub fn main() {
    let bulkDNSValidationRequest = ; // BulkDNSValidationRequest

    let mut context = CampaignsApi::Context::default();
    let result = client.bulkValidateDNS(bulkDNSValidationRequest, &context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Body parameters
Name Description
bulkDNSValidationRequest *

Responses

Name Type Format Description
Retry-After Integer Seconds to wait before retrying


bulkValidateHTTP

Bulk HTTP validation


/campaigns/bulk/domains/validate-http

Usage and SDK Samples

curl -X POST \
 \
 -H "Accept: application/json" \
 -H "Content-Type: application/json" \
 "https://api.domainflow.dev/api/v2/campaigns/bulk/domains/validate-http" \
 -d '{
  "operations" : [ {
    "keywords" : [ "keywords", "keywords" ],
    "maxDomains" : 801,
    "personaIds" : [ "046b6c7f-0b8a-43b9-b35d-6489e6daee91", "046b6c7f-0b8a-43b9-b35d-6489e6daee91" ],
    "campaignId" : "046b6c7f-0b8a-43b9-b35d-6489e6daee91",
    "validationConfig" : {
      "headers" : {
        "key" : "headers"
      },
      "followRedirects" : true,
      "userAgent" : "userAgent",
      "timeout" : 38151
    }
  }, {
    "keywords" : [ "keywords", "keywords" ],
    "maxDomains" : 801,
    "personaIds" : [ "046b6c7f-0b8a-43b9-b35d-6489e6daee91", "046b6c7f-0b8a-43b9-b35d-6489e6daee91" ],
    "campaignId" : "046b6c7f-0b8a-43b9-b35d-6489e6daee91",
    "validationConfig" : {
      "headers" : {
        "key" : "headers"
      },
      "followRedirects" : true,
      "userAgent" : "userAgent",
      "timeout" : 38151
    }
  }, {
    "keywords" : [ "keywords", "keywords" ],
    "maxDomains" : 801,
    "personaIds" : [ "046b6c7f-0b8a-43b9-b35d-6489e6daee91", "046b6c7f-0b8a-43b9-b35d-6489e6daee91" ],
    "campaignId" : "046b6c7f-0b8a-43b9-b35d-6489e6daee91",
    "validationConfig" : {
      "headers" : {
        "key" : "headers"
      },
      "followRedirects" : true,
      "userAgent" : "userAgent",
      "timeout" : 38151
    }
  }, {
    "keywords" : [ "keywords", "keywords" ],
    "maxDomains" : 801,
    "personaIds" : [ "046b6c7f-0b8a-43b9-b35d-6489e6daee91", "046b6c7f-0b8a-43b9-b35d-6489e6daee91" ],
    "campaignId" : "046b6c7f-0b8a-43b9-b35d-6489e6daee91",
    "validationConfig" : {
      "headers" : {
        "key" : "headers"
      },
      "followRedirects" : true,
      "userAgent" : "userAgent",
      "timeout" : 38151
    }
  }, {
    "keywords" : [ "keywords", "keywords" ],
    "maxDomains" : 801,
    "personaIds" : [ "046b6c7f-0b8a-43b9-b35d-6489e6daee91", "046b6c7f-0b8a-43b9-b35d-6489e6daee91" ],
    "campaignId" : "046b6c7f-0b8a-43b9-b35d-6489e6daee91",
    "validationConfig" : {
      "headers" : {
        "key" : "headers"
      },
      "followRedirects" : true,
      "userAgent" : "userAgent",
      "timeout" : 38151
    }
  } ],
  "stealth" : {
    "delayRange" : {
      "min" : 5,
      "max" : 2
    },
    "enabled" : true,
    "randomizationLevel" : "high"
  },
  "batchSize" : 74
}'
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.CampaignsApi;

import java.io.File;
import java.util.*;

public class CampaignsApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure API key authorization: cookieAuth
        ApiKeyAuth cookieAuth = (ApiKeyAuth) defaultClient.getAuthentication("cookieAuth");
        cookieAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //cookieAuth.setApiKeyPrefix("Token");

        // Create an instance of the API class
        CampaignsApi apiInstance = new CampaignsApi();
        BulkHTTPValidationRequest bulkHTTPValidationRequest = ; // BulkHTTPValidationRequest | 

        try {
            bulkValidateDNS_200_response result = apiInstance.bulkValidateHTTP(bulkHTTPValidationRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling CampaignsApi#bulkValidateHTTP");
            e.printStackTrace();
        }
    }
}
import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final BulkHTTPValidationRequest bulkHTTPValidationRequest = new BulkHTTPValidationRequest(); // BulkHTTPValidationRequest | 

try {
    final result = await api_instance.bulkValidateHTTP(bulkHTTPValidationRequest);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->bulkValidateHTTP: $e\n');
}

import org.openapitools.client.api.CampaignsApi;

public class CampaignsApiExample {
    public static void main(String[] args) {
        CampaignsApi apiInstance = new CampaignsApi();
        BulkHTTPValidationRequest bulkHTTPValidationRequest = ; // BulkHTTPValidationRequest | 

        try {
            bulkValidateDNS_200_response result = apiInstance.bulkValidateHTTP(bulkHTTPValidationRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling CampaignsApi#bulkValidateHTTP");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: cookieAuth)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"domainflow_session"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"domainflow_session"];


// Create an instance of the API class
CampaignsApi *apiInstance = [[CampaignsApi alloc] init];
BulkHTTPValidationRequest *bulkHTTPValidationRequest = ; // 

// Bulk HTTP validation
[apiInstance bulkValidateHTTPWith:bulkHTTPValidationRequest
              completionHandler: ^(bulkValidateDNS_200_response output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var DomainFlowApi = require('domain_flow_api');
var defaultClient = DomainFlowApi.ApiClient.instance;

// Configure API key authorization: cookieAuth
var cookieAuth = defaultClient.authentications['cookieAuth'];
cookieAuth.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//cookieAuth.apiKeyPrefix['domainflow_session'] = "Token";

// Create an instance of the API class
var api = new DomainFlowApi.CampaignsApi()
var bulkHTTPValidationRequest = ; // {BulkHTTPValidationRequest} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.bulkValidateHTTP(bulkHTTPValidationRequest, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class bulkValidateHTTPExample
    {
        public void main()
        {
            // Configure API key authorization: cookieAuth
            Configuration.Default.ApiKey.Add("domainflow_session", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("domainflow_session", "Bearer");

            // Create an instance of the API class
            var apiInstance = new CampaignsApi();
            var bulkHTTPValidationRequest = new BulkHTTPValidationRequest(); // BulkHTTPValidationRequest | 

            try {
                // Bulk HTTP validation
                bulkValidateDNS_200_response result = apiInstance.bulkValidateHTTP(bulkHTTPValidationRequest);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling CampaignsApi.bulkValidateHTTP: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure API key authorization: cookieAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('domainflow_session', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('domainflow_session', 'Bearer');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\CampaignsApi();
$bulkHTTPValidationRequest = ; // BulkHTTPValidationRequest | 

try {
    $result = $api_instance->bulkValidateHTTP($bulkHTTPValidationRequest);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling CampaignsApi->bulkValidateHTTP: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::CampaignsApi;

# Configure API key authorization: cookieAuth
$WWW::OPenAPIClient::Configuration::api_key->{'domainflow_session'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'domainflow_session'} = "Bearer";

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::CampaignsApi->new();
my $bulkHTTPValidationRequest = WWW::OPenAPIClient::Object::BulkHTTPValidationRequest->new(); # BulkHTTPValidationRequest | 

eval {
    my $result = $api_instance->bulkValidateHTTP(bulkHTTPValidationRequest => $bulkHTTPValidationRequest);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling CampaignsApi->bulkValidateHTTP: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure API key authorization: cookieAuth
openapi_client.configuration.api_key['domainflow_session'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['domainflow_session'] = 'Bearer'

# Create an instance of the API class
api_instance = openapi_client.CampaignsApi()
bulkHTTPValidationRequest =  # BulkHTTPValidationRequest | 

try:
    # Bulk HTTP validation
    api_response = api_instance.bulk_validate_http(bulkHTTPValidationRequest)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling CampaignsApi->bulkValidateHTTP: %s\n" % e)
extern crate CampaignsApi;

pub fn main() {
    let bulkHTTPValidationRequest = ; // BulkHTTPValidationRequest

    let mut context = CampaignsApi::Context::default();
    let result = client.bulkValidateHTTP(bulkHTTPValidationRequest, &context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Body parameters
Name Description
bulkHTTPValidationRequest *

Responses

Name Type Format Description
Retry-After Integer Seconds to wait before retrying


campaignsBulkOperationsList

List bulk operations


/campaigns/bulk/operations

Usage and SDK Samples

curl -X GET \
 \
 -H "Accept: application/json" \
 "https://api.domainflow.dev/api/v2/campaigns/bulk/operations"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.CampaignsApi;

import java.io.File;
import java.util.*;

public class CampaignsApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure API key authorization: cookieAuth
        ApiKeyAuth cookieAuth = (ApiKeyAuth) defaultClient.getAuthentication("cookieAuth");
        cookieAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //cookieAuth.setApiKeyPrefix("Token");

        // Create an instance of the API class
        CampaignsApi apiInstance = new CampaignsApi();

        try {
            campaigns_bulk_operations_list_200_response result = apiInstance.campaignsBulkOperationsList();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling CampaignsApi#campaignsBulkOperationsList");
            e.printStackTrace();
        }
    }
}
import 'package:openapi/api.dart';

final api_instance = DefaultApi();


try {
    final result = await api_instance.campaignsBulkOperationsList();
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->campaignsBulkOperationsList: $e\n');
}

import org.openapitools.client.api.CampaignsApi;

public class CampaignsApiExample {
    public static void main(String[] args) {
        CampaignsApi apiInstance = new CampaignsApi();

        try {
            campaigns_bulk_operations_list_200_response result = apiInstance.campaignsBulkOperationsList();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling CampaignsApi#campaignsBulkOperationsList");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: cookieAuth)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"domainflow_session"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"domainflow_session"];


// Create an instance of the API class
CampaignsApi *apiInstance = [[CampaignsApi alloc] init];

// List bulk operations
[apiInstance campaignsBulkOperationsListWithCompletionHandler: 
              ^(campaigns_bulk_operations_list_200_response output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var DomainFlowApi = require('domain_flow_api');
var defaultClient = DomainFlowApi.ApiClient.instance;

// Configure API key authorization: cookieAuth
var cookieAuth = defaultClient.authentications['cookieAuth'];
cookieAuth.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//cookieAuth.apiKeyPrefix['domainflow_session'] = "Token";

// Create an instance of the API class
var api = new DomainFlowApi.CampaignsApi()
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.campaignsBulkOperationsList(callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class campaignsBulkOperationsListExample
    {
        public void main()
        {
            // Configure API key authorization: cookieAuth
            Configuration.Default.ApiKey.Add("domainflow_session", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("domainflow_session", "Bearer");

            // Create an instance of the API class
            var apiInstance = new CampaignsApi();

            try {
                // List bulk operations
                campaigns_bulk_operations_list_200_response result = apiInstance.campaignsBulkOperationsList();
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling CampaignsApi.campaignsBulkOperationsList: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure API key authorization: cookieAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('domainflow_session', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('domainflow_session', 'Bearer');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\CampaignsApi();

try {
    $result = $api_instance->campaignsBulkOperationsList();
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling CampaignsApi->campaignsBulkOperationsList: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::CampaignsApi;

# Configure API key authorization: cookieAuth
$WWW::OPenAPIClient::Configuration::api_key->{'domainflow_session'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'domainflow_session'} = "Bearer";

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::CampaignsApi->new();

eval {
    my $result = $api_instance->campaignsBulkOperationsList();
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling CampaignsApi->campaignsBulkOperationsList: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure API key authorization: cookieAuth
openapi_client.configuration.api_key['domainflow_session'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['domainflow_session'] = 'Bearer'

# Create an instance of the API class
api_instance = openapi_client.CampaignsApi()

try:
    # List bulk operations
    api_response = api_instance.campaigns_bulk_operations_list()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling CampaignsApi->campaignsBulkOperationsList: %s\n" % e)
extern crate CampaignsApi;

pub fn main() {

    let mut context = CampaignsApi::Context::default();
    let result = client.campaignsBulkOperationsList(&context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Responses

Name Type Format Description
Retry-After Integer Seconds to wait before retrying


campaignsCreate

Create campaign


/campaigns

Usage and SDK Samples

curl -X POST \
 \
 -H "Accept: application/json" \
 -H "Content-Type: application/json" \
 "https://api.domainflow.dev/api/v2/campaigns" \
 -d '{
  "configuration" : {
    "maxDomains" : 80083,
    "phases" : {
      "discovery" : {
        "maxDepth" : 6,
        "enabled" : true
      },
      "extraction" : {
        "keywordSetIds" : [ "046b6c7f-0b8a-43b9-b35d-6489e6daee91", "046b6c7f-0b8a-43b9-b35d-6489e6daee91" ],
        "enabled" : true
      },
      "analysis" : {
        "generateReports" : true,
        "enabled" : true
      },
      "validation" : {
        "dnsValidation" : true,
        "enabled" : true,
        "httpValidation" : true
      }
    }
  },
  "name" : "name",
  "description" : "description"
}'
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.CampaignsApi;

import java.io.File;
import java.util.*;

public class CampaignsApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure API key authorization: cookieAuth
        ApiKeyAuth cookieAuth = (ApiKeyAuth) defaultClient.getAuthentication("cookieAuth");
        cookieAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //cookieAuth.setApiKeyPrefix("Token");

        // Create an instance of the API class
        CampaignsApi apiInstance = new CampaignsApi();
        CreateCampaignRequest createCampaignRequest = ; // CreateCampaignRequest | 

        try {
            campaigns_create_201_response result = apiInstance.campaignsCreate(createCampaignRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling CampaignsApi#campaignsCreate");
            e.printStackTrace();
        }
    }
}
import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final CreateCampaignRequest createCampaignRequest = new CreateCampaignRequest(); // CreateCampaignRequest | 

try {
    final result = await api_instance.campaignsCreate(createCampaignRequest);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->campaignsCreate: $e\n');
}

import org.openapitools.client.api.CampaignsApi;

public class CampaignsApiExample {
    public static void main(String[] args) {
        CampaignsApi apiInstance = new CampaignsApi();
        CreateCampaignRequest createCampaignRequest = ; // CreateCampaignRequest | 

        try {
            campaigns_create_201_response result = apiInstance.campaignsCreate(createCampaignRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling CampaignsApi#campaignsCreate");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: cookieAuth)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"domainflow_session"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"domainflow_session"];


// Create an instance of the API class
CampaignsApi *apiInstance = [[CampaignsApi alloc] init];
CreateCampaignRequest *createCampaignRequest = ; // 

// Create campaign
[apiInstance campaignsCreateWith:createCampaignRequest
              completionHandler: ^(campaigns_create_201_response output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var DomainFlowApi = require('domain_flow_api');
var defaultClient = DomainFlowApi.ApiClient.instance;

// Configure API key authorization: cookieAuth
var cookieAuth = defaultClient.authentications['cookieAuth'];
cookieAuth.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//cookieAuth.apiKeyPrefix['domainflow_session'] = "Token";

// Create an instance of the API class
var api = new DomainFlowApi.CampaignsApi()
var createCampaignRequest = ; // {CreateCampaignRequest} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.campaignsCreate(createCampaignRequest, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class campaignsCreateExample
    {
        public void main()
        {
            // Configure API key authorization: cookieAuth
            Configuration.Default.ApiKey.Add("domainflow_session", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("domainflow_session", "Bearer");

            // Create an instance of the API class
            var apiInstance = new CampaignsApi();
            var createCampaignRequest = new CreateCampaignRequest(); // CreateCampaignRequest | 

            try {
                // Create campaign
                campaigns_create_201_response result = apiInstance.campaignsCreate(createCampaignRequest);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling CampaignsApi.campaignsCreate: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure API key authorization: cookieAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('domainflow_session', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('domainflow_session', 'Bearer');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\CampaignsApi();
$createCampaignRequest = ; // CreateCampaignRequest | 

try {
    $result = $api_instance->campaignsCreate($createCampaignRequest);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling CampaignsApi->campaignsCreate: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::CampaignsApi;

# Configure API key authorization: cookieAuth
$WWW::OPenAPIClient::Configuration::api_key->{'domainflow_session'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'domainflow_session'} = "Bearer";

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::CampaignsApi->new();
my $createCampaignRequest = WWW::OPenAPIClient::Object::CreateCampaignRequest->new(); # CreateCampaignRequest | 

eval {
    my $result = $api_instance->campaignsCreate(createCampaignRequest => $createCampaignRequest);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling CampaignsApi->campaignsCreate: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure API key authorization: cookieAuth
openapi_client.configuration.api_key['domainflow_session'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['domainflow_session'] = 'Bearer'

# Create an instance of the API class
api_instance = openapi_client.CampaignsApi()
createCampaignRequest =  # CreateCampaignRequest | 

try:
    # Create campaign
    api_response = api_instance.campaigns_create(createCampaignRequest)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling CampaignsApi->campaignsCreate: %s\n" % e)
extern crate CampaignsApi;

pub fn main() {
    let createCampaignRequest = ; // CreateCampaignRequest

    let mut context = CampaignsApi::Context::default();
    let result = client.campaignsCreate(createCampaignRequest, &context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Body parameters
Name Description
createCampaignRequest *

Responses


campaignsDelete

Delete campaign


/campaigns/{campaignId}

Usage and SDK Samples

curl -X DELETE \
 \
 -H "Accept: application/json" \
 "https://api.domainflow.dev/api/v2/campaigns/{campaignId}"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.CampaignsApi;

import java.io.File;
import java.util.*;

public class CampaignsApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure API key authorization: cookieAuth
        ApiKeyAuth cookieAuth = (ApiKeyAuth) defaultClient.getAuthentication("cookieAuth");
        cookieAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //cookieAuth.setApiKeyPrefix("Token");

        // Create an instance of the API class
        CampaignsApi apiInstance = new CampaignsApi();
        UUID campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 

        try {
            apiInstance.campaignsDelete(campaignId);
        } catch (ApiException e) {
            System.err.println("Exception when calling CampaignsApi#campaignsDelete");
            e.printStackTrace();
        }
    }
}
import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final UUID campaignId = new UUID(); // UUID | 

try {
    final result = await api_instance.campaignsDelete(campaignId);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->campaignsDelete: $e\n');
}

import org.openapitools.client.api.CampaignsApi;

public class CampaignsApiExample {
    public static void main(String[] args) {
        CampaignsApi apiInstance = new CampaignsApi();
        UUID campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 

        try {
            apiInstance.campaignsDelete(campaignId);
        } catch (ApiException e) {
            System.err.println("Exception when calling CampaignsApi#campaignsDelete");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: cookieAuth)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"domainflow_session"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"domainflow_session"];


// Create an instance of the API class
CampaignsApi *apiInstance = [[CampaignsApi alloc] init];
UUID *campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; //  (default to null)

// Delete campaign
[apiInstance campaignsDeleteWith:campaignId
              completionHandler: ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var DomainFlowApi = require('domain_flow_api');
var defaultClient = DomainFlowApi.ApiClient.instance;

// Configure API key authorization: cookieAuth
var cookieAuth = defaultClient.authentications['cookieAuth'];
cookieAuth.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//cookieAuth.apiKeyPrefix['domainflow_session'] = "Token";

// Create an instance of the API class
var api = new DomainFlowApi.CampaignsApi()
var campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // {UUID} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.campaignsDelete(campaignId, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class campaignsDeleteExample
    {
        public void main()
        {
            // Configure API key authorization: cookieAuth
            Configuration.Default.ApiKey.Add("domainflow_session", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("domainflow_session", "Bearer");

            // Create an instance of the API class
            var apiInstance = new CampaignsApi();
            var campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d;  // UUID |  (default to null)

            try {
                // Delete campaign
                apiInstance.campaignsDelete(campaignId);
            } catch (Exception e) {
                Debug.Print("Exception when calling CampaignsApi.campaignsDelete: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure API key authorization: cookieAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('domainflow_session', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('domainflow_session', 'Bearer');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\CampaignsApi();
$campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 

try {
    $api_instance->campaignsDelete($campaignId);
} catch (Exception $e) {
    echo 'Exception when calling CampaignsApi->campaignsDelete: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::CampaignsApi;

# Configure API key authorization: cookieAuth
$WWW::OPenAPIClient::Configuration::api_key->{'domainflow_session'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'domainflow_session'} = "Bearer";

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::CampaignsApi->new();
my $campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; # UUID | 

eval {
    $api_instance->campaignsDelete(campaignId => $campaignId);
};
if ($@) {
    warn "Exception when calling CampaignsApi->campaignsDelete: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure API key authorization: cookieAuth
openapi_client.configuration.api_key['domainflow_session'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['domainflow_session'] = 'Bearer'

# Create an instance of the API class
api_instance = openapi_client.CampaignsApi()
campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d # UUID |  (default to null)

try:
    # Delete campaign
    api_instance.campaigns_delete(campaignId)
except ApiException as e:
    print("Exception when calling CampaignsApi->campaignsDelete: %s\n" % e)
extern crate CampaignsApi;

pub fn main() {
    let campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID

    let mut context = CampaignsApi::Context::default();
    let result = client.campaignsDelete(campaignId, &context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Path parameters
Name Description
campaignId*
UUID (uuid)
Required

Responses


campaignsDomainGenerationPatternOffset

Get current global pattern offset for domain generation config


/campaigns/domain-generation/pattern-offset

Usage and SDK Samples

curl -X POST \
 \
 -H "Accept: application/json" \
 -H "Content-Type: application/json" \
 "https://api.domainflow.dev/api/v2/campaigns/domain-generation/pattern-offset" \
 -d '{
  "characterSet" : "characterSet",
  "variableLength" : 0,
  "patternType" : "prefix",
  "constantString" : "constantString",
  "tld" : "tld"
}'
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.CampaignsApi;

import java.io.File;
import java.util.*;

public class CampaignsApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure API key authorization: cookieAuth
        ApiKeyAuth cookieAuth = (ApiKeyAuth) defaultClient.getAuthentication("cookieAuth");
        cookieAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //cookieAuth.setApiKeyPrefix("Token");

        // Create an instance of the API class
        CampaignsApi apiInstance = new CampaignsApi();
        PatternOffsetRequest patternOffsetRequest = ; // PatternOffsetRequest | 

        try {
            campaigns_domain_generation_pattern_offset_200_response result = apiInstance.campaignsDomainGenerationPatternOffset(patternOffsetRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling CampaignsApi#campaignsDomainGenerationPatternOffset");
            e.printStackTrace();
        }
    }
}
import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final PatternOffsetRequest patternOffsetRequest = new PatternOffsetRequest(); // PatternOffsetRequest | 

try {
    final result = await api_instance.campaignsDomainGenerationPatternOffset(patternOffsetRequest);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->campaignsDomainGenerationPatternOffset: $e\n');
}

import org.openapitools.client.api.CampaignsApi;

public class CampaignsApiExample {
    public static void main(String[] args) {
        CampaignsApi apiInstance = new CampaignsApi();
        PatternOffsetRequest patternOffsetRequest = ; // PatternOffsetRequest | 

        try {
            campaigns_domain_generation_pattern_offset_200_response result = apiInstance.campaignsDomainGenerationPatternOffset(patternOffsetRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling CampaignsApi#campaignsDomainGenerationPatternOffset");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: cookieAuth)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"domainflow_session"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"domainflow_session"];


// Create an instance of the API class
CampaignsApi *apiInstance = [[CampaignsApi alloc] init];
PatternOffsetRequest *patternOffsetRequest = ; // 

// Get current global pattern offset for domain generation config
[apiInstance campaignsDomainGenerationPatternOffsetWith:patternOffsetRequest
              completionHandler: ^(campaigns_domain_generation_pattern_offset_200_response output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var DomainFlowApi = require('domain_flow_api');
var defaultClient = DomainFlowApi.ApiClient.instance;

// Configure API key authorization: cookieAuth
var cookieAuth = defaultClient.authentications['cookieAuth'];
cookieAuth.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//cookieAuth.apiKeyPrefix['domainflow_session'] = "Token";

// Create an instance of the API class
var api = new DomainFlowApi.CampaignsApi()
var patternOffsetRequest = ; // {PatternOffsetRequest} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.campaignsDomainGenerationPatternOffset(patternOffsetRequest, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class campaignsDomainGenerationPatternOffsetExample
    {
        public void main()
        {
            // Configure API key authorization: cookieAuth
            Configuration.Default.ApiKey.Add("domainflow_session", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("domainflow_session", "Bearer");

            // Create an instance of the API class
            var apiInstance = new CampaignsApi();
            var patternOffsetRequest = new PatternOffsetRequest(); // PatternOffsetRequest | 

            try {
                // Get current global pattern offset for domain generation config
                campaigns_domain_generation_pattern_offset_200_response result = apiInstance.campaignsDomainGenerationPatternOffset(patternOffsetRequest);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling CampaignsApi.campaignsDomainGenerationPatternOffset: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure API key authorization: cookieAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('domainflow_session', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('domainflow_session', 'Bearer');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\CampaignsApi();
$patternOffsetRequest = ; // PatternOffsetRequest | 

try {
    $result = $api_instance->campaignsDomainGenerationPatternOffset($patternOffsetRequest);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling CampaignsApi->campaignsDomainGenerationPatternOffset: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::CampaignsApi;

# Configure API key authorization: cookieAuth
$WWW::OPenAPIClient::Configuration::api_key->{'domainflow_session'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'domainflow_session'} = "Bearer";

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::CampaignsApi->new();
my $patternOffsetRequest = WWW::OPenAPIClient::Object::PatternOffsetRequest->new(); # PatternOffsetRequest | 

eval {
    my $result = $api_instance->campaignsDomainGenerationPatternOffset(patternOffsetRequest => $patternOffsetRequest);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling CampaignsApi->campaignsDomainGenerationPatternOffset: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure API key authorization: cookieAuth
openapi_client.configuration.api_key['domainflow_session'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['domainflow_session'] = 'Bearer'

# Create an instance of the API class
api_instance = openapi_client.CampaignsApi()
patternOffsetRequest =  # PatternOffsetRequest | 

try:
    # Get current global pattern offset for domain generation config
    api_response = api_instance.campaigns_domain_generation_pattern_offset(patternOffsetRequest)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling CampaignsApi->campaignsDomainGenerationPatternOffset: %s\n" % e)
extern crate CampaignsApi;

pub fn main() {
    let patternOffsetRequest = ; // PatternOffsetRequest

    let mut context = CampaignsApi::Context::default();
    let result = client.campaignsDomainGenerationPatternOffset(patternOffsetRequest, &context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Body parameters
Name Description
patternOffsetRequest *

Responses


campaignsDomainsList

List generated domains for a campaign


/campaigns/{campaignId}/domains

Usage and SDK Samples

curl -X GET \
 \
 -H "Accept: application/json" \
 "https://api.domainflow.dev/api/v2/campaigns/{campaignId}/domains?limit=56&offset=56"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.CampaignsApi;

import java.io.File;
import java.util.*;

public class CampaignsApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure API key authorization: cookieAuth
        ApiKeyAuth cookieAuth = (ApiKeyAuth) defaultClient.getAuthentication("cookieAuth");
        cookieAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //cookieAuth.setApiKeyPrefix("Token");

        // Create an instance of the API class
        CampaignsApi apiInstance = new CampaignsApi();
        UUID campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 
        Integer limit = 56; // Integer | 
        Integer offset = 56; // Integer | 

        try {
            campaigns_domains_list_200_response result = apiInstance.campaignsDomainsList(campaignId, limit, offset);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling CampaignsApi#campaignsDomainsList");
            e.printStackTrace();
        }
    }
}
import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final UUID campaignId = new UUID(); // UUID | 
final Integer limit = new Integer(); // Integer | 
final Integer offset = new Integer(); // Integer | 

try {
    final result = await api_instance.campaignsDomainsList(campaignId, limit, offset);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->campaignsDomainsList: $e\n');
}

import org.openapitools.client.api.CampaignsApi;

public class CampaignsApiExample {
    public static void main(String[] args) {
        CampaignsApi apiInstance = new CampaignsApi();
        UUID campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 
        Integer limit = 56; // Integer | 
        Integer offset = 56; // Integer | 

        try {
            campaigns_domains_list_200_response result = apiInstance.campaignsDomainsList(campaignId, limit, offset);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling CampaignsApi#campaignsDomainsList");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: cookieAuth)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"domainflow_session"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"domainflow_session"];


// Create an instance of the API class
CampaignsApi *apiInstance = [[CampaignsApi alloc] init];
UUID *campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; //  (default to null)
Integer *limit = 56; //  (optional) (default to 100)
Integer *offset = 56; //  (optional) (default to 0)

// List generated domains for a campaign
[apiInstance campaignsDomainsListWith:campaignId
    limit:limit
    offset:offset
              completionHandler: ^(campaigns_domains_list_200_response output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var DomainFlowApi = require('domain_flow_api');
var defaultClient = DomainFlowApi.ApiClient.instance;

// Configure API key authorization: cookieAuth
var cookieAuth = defaultClient.authentications['cookieAuth'];
cookieAuth.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//cookieAuth.apiKeyPrefix['domainflow_session'] = "Token";

// Create an instance of the API class
var api = new DomainFlowApi.CampaignsApi()
var campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // {UUID} 
var opts = {
  'limit': 56, // {Integer} 
  'offset': 56 // {Integer} 
};

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.campaignsDomainsList(campaignId, opts, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class campaignsDomainsListExample
    {
        public void main()
        {
            // Configure API key authorization: cookieAuth
            Configuration.Default.ApiKey.Add("domainflow_session", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("domainflow_session", "Bearer");

            // Create an instance of the API class
            var apiInstance = new CampaignsApi();
            var campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d;  // UUID |  (default to null)
            var limit = 56;  // Integer |  (optional)  (default to 100)
            var offset = 56;  // Integer |  (optional)  (default to 0)

            try {
                // List generated domains for a campaign
                campaigns_domains_list_200_response result = apiInstance.campaignsDomainsList(campaignId, limit, offset);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling CampaignsApi.campaignsDomainsList: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure API key authorization: cookieAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('domainflow_session', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('domainflow_session', 'Bearer');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\CampaignsApi();
$campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 
$limit = 56; // Integer | 
$offset = 56; // Integer | 

try {
    $result = $api_instance->campaignsDomainsList($campaignId, $limit, $offset);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling CampaignsApi->campaignsDomainsList: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::CampaignsApi;

# Configure API key authorization: cookieAuth
$WWW::OPenAPIClient::Configuration::api_key->{'domainflow_session'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'domainflow_session'} = "Bearer";

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::CampaignsApi->new();
my $campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; # UUID | 
my $limit = 56; # Integer | 
my $offset = 56; # Integer | 

eval {
    my $result = $api_instance->campaignsDomainsList(campaignId => $campaignId, limit => $limit, offset => $offset);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling CampaignsApi->campaignsDomainsList: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure API key authorization: cookieAuth
openapi_client.configuration.api_key['domainflow_session'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['domainflow_session'] = 'Bearer'

# Create an instance of the API class
api_instance = openapi_client.CampaignsApi()
campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d # UUID |  (default to null)
limit = 56 # Integer |  (optional) (default to 100)
offset = 56 # Integer |  (optional) (default to 0)

try:
    # List generated domains for a campaign
    api_response = api_instance.campaigns_domains_list(campaignId, limit=limit, offset=offset)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling CampaignsApi->campaignsDomainsList: %s\n" % e)
extern crate CampaignsApi;

pub fn main() {
    let campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID
    let limit = 56; // Integer
    let offset = 56; // Integer

    let mut context = CampaignsApi::Context::default();
    let result = client.campaignsDomainsList(campaignId, limit, offset, &context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Path parameters
Name Description
campaignId*
UUID (uuid)
Required
Query parameters
Name Description
limit
Integer
offset
Integer

Responses


campaignsEnrichedGet

Get enriched campaign details

Returns campaign with state and recent phase executions as a single enriched read model


/campaigns/{campaignId}/enriched

Usage and SDK Samples

curl -X GET \
 \
 -H "Accept: application/json" \
 "https://api.domainflow.dev/api/v2/campaigns/{campaignId}/enriched"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.CampaignsApi;

import java.io.File;
import java.util.*;

public class CampaignsApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure API key authorization: cookieAuth
        ApiKeyAuth cookieAuth = (ApiKeyAuth) defaultClient.getAuthentication("cookieAuth");
        cookieAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //cookieAuth.setApiKeyPrefix("Token");

        // Create an instance of the API class
        CampaignsApi apiInstance = new CampaignsApi();
        UUID campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 

        try {
            campaigns_enriched_get_200_response result = apiInstance.campaignsEnrichedGet(campaignId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling CampaignsApi#campaignsEnrichedGet");
            e.printStackTrace();
        }
    }
}
import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final UUID campaignId = new UUID(); // UUID | 

try {
    final result = await api_instance.campaignsEnrichedGet(campaignId);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->campaignsEnrichedGet: $e\n');
}

import org.openapitools.client.api.CampaignsApi;

public class CampaignsApiExample {
    public static void main(String[] args) {
        CampaignsApi apiInstance = new CampaignsApi();
        UUID campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 

        try {
            campaigns_enriched_get_200_response result = apiInstance.campaignsEnrichedGet(campaignId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling CampaignsApi#campaignsEnrichedGet");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: cookieAuth)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"domainflow_session"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"domainflow_session"];


// Create an instance of the API class
CampaignsApi *apiInstance = [[CampaignsApi alloc] init];
UUID *campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; //  (default to null)

// Get enriched campaign details
[apiInstance campaignsEnrichedGetWith:campaignId
              completionHandler: ^(campaigns_enriched_get_200_response output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var DomainFlowApi = require('domain_flow_api');
var defaultClient = DomainFlowApi.ApiClient.instance;

// Configure API key authorization: cookieAuth
var cookieAuth = defaultClient.authentications['cookieAuth'];
cookieAuth.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//cookieAuth.apiKeyPrefix['domainflow_session'] = "Token";

// Create an instance of the API class
var api = new DomainFlowApi.CampaignsApi()
var campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // {UUID} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.campaignsEnrichedGet(campaignId, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class campaignsEnrichedGetExample
    {
        public void main()
        {
            // Configure API key authorization: cookieAuth
            Configuration.Default.ApiKey.Add("domainflow_session", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("domainflow_session", "Bearer");

            // Create an instance of the API class
            var apiInstance = new CampaignsApi();
            var campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d;  // UUID |  (default to null)

            try {
                // Get enriched campaign details
                campaigns_enriched_get_200_response result = apiInstance.campaignsEnrichedGet(campaignId);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling CampaignsApi.campaignsEnrichedGet: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure API key authorization: cookieAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('domainflow_session', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('domainflow_session', 'Bearer');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\CampaignsApi();
$campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 

try {
    $result = $api_instance->campaignsEnrichedGet($campaignId);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling CampaignsApi->campaignsEnrichedGet: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::CampaignsApi;

# Configure API key authorization: cookieAuth
$WWW::OPenAPIClient::Configuration::api_key->{'domainflow_session'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'domainflow_session'} = "Bearer";

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::CampaignsApi->new();
my $campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; # UUID | 

eval {
    my $result = $api_instance->campaignsEnrichedGet(campaignId => $campaignId);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling CampaignsApi->campaignsEnrichedGet: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure API key authorization: cookieAuth
openapi_client.configuration.api_key['domainflow_session'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['domainflow_session'] = 'Bearer'

# Create an instance of the API class
api_instance = openapi_client.CampaignsApi()
campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d # UUID |  (default to null)

try:
    # Get enriched campaign details
    api_response = api_instance.campaigns_enriched_get(campaignId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling CampaignsApi->campaignsEnrichedGet: %s\n" % e)
extern crate CampaignsApi;

pub fn main() {
    let campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID

    let mut context = CampaignsApi::Context::default();
    let result = client.campaignsEnrichedGet(campaignId, &context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Path parameters
Name Description
campaignId*
UUID (uuid)
Required

Responses


campaignsGet

Get campaign


/campaigns/{campaignId}

Usage and SDK Samples

curl -X GET \
 \
 -H "Accept: application/json" \
 "https://api.domainflow.dev/api/v2/campaigns/{campaignId}"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.CampaignsApi;

import java.io.File;
import java.util.*;

public class CampaignsApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure API key authorization: cookieAuth
        ApiKeyAuth cookieAuth = (ApiKeyAuth) defaultClient.getAuthentication("cookieAuth");
        cookieAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //cookieAuth.setApiKeyPrefix("Token");

        // Create an instance of the API class
        CampaignsApi apiInstance = new CampaignsApi();
        UUID campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 

        try {
            campaigns_create_201_response result = apiInstance.campaignsGet(campaignId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling CampaignsApi#campaignsGet");
            e.printStackTrace();
        }
    }
}
import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final UUID campaignId = new UUID(); // UUID | 

try {
    final result = await api_instance.campaignsGet(campaignId);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->campaignsGet: $e\n');
}

import org.openapitools.client.api.CampaignsApi;

public class CampaignsApiExample {
    public static void main(String[] args) {
        CampaignsApi apiInstance = new CampaignsApi();
        UUID campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 

        try {
            campaigns_create_201_response result = apiInstance.campaignsGet(campaignId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling CampaignsApi#campaignsGet");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: cookieAuth)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"domainflow_session"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"domainflow_session"];


// Create an instance of the API class
CampaignsApi *apiInstance = [[CampaignsApi alloc] init];
UUID *campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; //  (default to null)

// Get campaign
[apiInstance campaignsGetWith:campaignId
              completionHandler: ^(campaigns_create_201_response output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var DomainFlowApi = require('domain_flow_api');
var defaultClient = DomainFlowApi.ApiClient.instance;

// Configure API key authorization: cookieAuth
var cookieAuth = defaultClient.authentications['cookieAuth'];
cookieAuth.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//cookieAuth.apiKeyPrefix['domainflow_session'] = "Token";

// Create an instance of the API class
var api = new DomainFlowApi.CampaignsApi()
var campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // {UUID} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.campaignsGet(campaignId, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class campaignsGetExample
    {
        public void main()
        {
            // Configure API key authorization: cookieAuth
            Configuration.Default.ApiKey.Add("domainflow_session", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("domainflow_session", "Bearer");

            // Create an instance of the API class
            var apiInstance = new CampaignsApi();
            var campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d;  // UUID |  (default to null)

            try {
                // Get campaign
                campaigns_create_201_response result = apiInstance.campaignsGet(campaignId);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling CampaignsApi.campaignsGet: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure API key authorization: cookieAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('domainflow_session', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('domainflow_session', 'Bearer');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\CampaignsApi();
$campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 

try {
    $result = $api_instance->campaignsGet($campaignId);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling CampaignsApi->campaignsGet: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::CampaignsApi;

# Configure API key authorization: cookieAuth
$WWW::OPenAPIClient::Configuration::api_key->{'domainflow_session'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'domainflow_session'} = "Bearer";

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::CampaignsApi->new();
my $campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; # UUID | 

eval {
    my $result = $api_instance->campaignsGet(campaignId => $campaignId);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling CampaignsApi->campaignsGet: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure API key authorization: cookieAuth
openapi_client.configuration.api_key['domainflow_session'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['domainflow_session'] = 'Bearer'

# Create an instance of the API class
api_instance = openapi_client.CampaignsApi()
campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d # UUID |  (default to null)

try:
    # Get campaign
    api_response = api_instance.campaigns_get(campaignId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling CampaignsApi->campaignsGet: %s\n" % e)
extern crate CampaignsApi;

pub fn main() {
    let campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID

    let mut context = CampaignsApi::Context::default();
    let result = client.campaignsGet(campaignId, &context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Path parameters
Name Description
campaignId*
UUID (uuid)
Required

Responses


campaignsList

List campaigns


/campaigns

Usage and SDK Samples

curl -X GET \
 \
 -H "Accept: application/json" \
 "https://api.domainflow.dev/api/v2/campaigns"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.CampaignsApi;

import java.io.File;
import java.util.*;

public class CampaignsApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure API key authorization: cookieAuth
        ApiKeyAuth cookieAuth = (ApiKeyAuth) defaultClient.getAuthentication("cookieAuth");
        cookieAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //cookieAuth.setApiKeyPrefix("Token");

        // Create an instance of the API class
        CampaignsApi apiInstance = new CampaignsApi();

        try {
            campaigns_list_200_response result = apiInstance.campaignsList();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling CampaignsApi#campaignsList");
            e.printStackTrace();
        }
    }
}
import 'package:openapi/api.dart';

final api_instance = DefaultApi();


try {
    final result = await api_instance.campaignsList();
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->campaignsList: $e\n');
}

import org.openapitools.client.api.CampaignsApi;

public class CampaignsApiExample {
    public static void main(String[] args) {
        CampaignsApi apiInstance = new CampaignsApi();

        try {
            campaigns_list_200_response result = apiInstance.campaignsList();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling CampaignsApi#campaignsList");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: cookieAuth)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"domainflow_session"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"domainflow_session"];


// Create an instance of the API class
CampaignsApi *apiInstance = [[CampaignsApi alloc] init];

// List campaigns
[apiInstance campaignsListWithCompletionHandler: 
              ^(campaigns_list_200_response output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var DomainFlowApi = require('domain_flow_api');
var defaultClient = DomainFlowApi.ApiClient.instance;

// Configure API key authorization: cookieAuth
var cookieAuth = defaultClient.authentications['cookieAuth'];
cookieAuth.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//cookieAuth.apiKeyPrefix['domainflow_session'] = "Token";

// Create an instance of the API class
var api = new DomainFlowApi.CampaignsApi()
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.campaignsList(callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class campaignsListExample
    {
        public void main()
        {
            // Configure API key authorization: cookieAuth
            Configuration.Default.ApiKey.Add("domainflow_session", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("domainflow_session", "Bearer");

            // Create an instance of the API class
            var apiInstance = new CampaignsApi();

            try {
                // List campaigns
                campaigns_list_200_response result = apiInstance.campaignsList();
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling CampaignsApi.campaignsList: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure API key authorization: cookieAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('domainflow_session', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('domainflow_session', 'Bearer');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\CampaignsApi();

try {
    $result = $api_instance->campaignsList();
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling CampaignsApi->campaignsList: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::CampaignsApi;

# Configure API key authorization: cookieAuth
$WWW::OPenAPIClient::Configuration::api_key->{'domainflow_session'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'domainflow_session'} = "Bearer";

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::CampaignsApi->new();

eval {
    my $result = $api_instance->campaignsList();
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling CampaignsApi->campaignsList: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure API key authorization: cookieAuth
openapi_client.configuration.api_key['domainflow_session'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['domainflow_session'] = 'Bearer'

# Create an instance of the API class
api_instance = openapi_client.CampaignsApi()

try:
    # List campaigns
    api_response = api_instance.campaigns_list()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling CampaignsApi->campaignsList: %s\n" % e)
extern crate CampaignsApi;

pub fn main() {

    let mut context = CampaignsApi::Context::default();
    let result = client.campaignsList(&context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Responses


campaignsModeUpdate

Update campaign execution mode


/campaigns/{campaignId}/mode

Usage and SDK Samples

curl -X PATCH \
 \
 -H "Accept: application/json" \
 -H "Content-Type: application/json" \
 "https://api.domainflow.dev/api/v2/campaigns/{campaignId}/mode" \
 -d ''
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.CampaignsApi;

import java.io.File;
import java.util.*;

public class CampaignsApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure API key authorization: cookieAuth
        ApiKeyAuth cookieAuth = (ApiKeyAuth) defaultClient.getAuthentication("cookieAuth");
        cookieAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //cookieAuth.setApiKeyPrefix("Token");

        // Create an instance of the API class
        CampaignsApi apiInstance = new CampaignsApi();
        UUID campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 
        CampaignsModeUpdateRequest campaignsModeUpdateRequest = ; // CampaignsModeUpdateRequest | 

        try {
            campaigns_mode_update_200_response result = apiInstance.campaignsModeUpdate(campaignId, campaignsModeUpdateRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling CampaignsApi#campaignsModeUpdate");
            e.printStackTrace();
        }
    }
}
import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final UUID campaignId = new UUID(); // UUID | 
final CampaignsModeUpdateRequest campaignsModeUpdateRequest = new CampaignsModeUpdateRequest(); // CampaignsModeUpdateRequest | 

try {
    final result = await api_instance.campaignsModeUpdate(campaignId, campaignsModeUpdateRequest);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->campaignsModeUpdate: $e\n');
}

import org.openapitools.client.api.CampaignsApi;

public class CampaignsApiExample {
    public static void main(String[] args) {
        CampaignsApi apiInstance = new CampaignsApi();
        UUID campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 
        CampaignsModeUpdateRequest campaignsModeUpdateRequest = ; // CampaignsModeUpdateRequest | 

        try {
            campaigns_mode_update_200_response result = apiInstance.campaignsModeUpdate(campaignId, campaignsModeUpdateRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling CampaignsApi#campaignsModeUpdate");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: cookieAuth)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"domainflow_session"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"domainflow_session"];


// Create an instance of the API class
CampaignsApi *apiInstance = [[CampaignsApi alloc] init];
UUID *campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; //  (default to null)
CampaignsModeUpdateRequest *campaignsModeUpdateRequest = ; // 

// Update campaign execution mode
[apiInstance campaignsModeUpdateWith:campaignId
    campaignsModeUpdateRequest:campaignsModeUpdateRequest
              completionHandler: ^(campaigns_mode_update_200_response output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var DomainFlowApi = require('domain_flow_api');
var defaultClient = DomainFlowApi.ApiClient.instance;

// Configure API key authorization: cookieAuth
var cookieAuth = defaultClient.authentications['cookieAuth'];
cookieAuth.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//cookieAuth.apiKeyPrefix['domainflow_session'] = "Token";

// Create an instance of the API class
var api = new DomainFlowApi.CampaignsApi()
var campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // {UUID} 
var campaignsModeUpdateRequest = ; // {CampaignsModeUpdateRequest} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.campaignsModeUpdate(campaignId, campaignsModeUpdateRequest, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class campaignsModeUpdateExample
    {
        public void main()
        {
            // Configure API key authorization: cookieAuth
            Configuration.Default.ApiKey.Add("domainflow_session", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("domainflow_session", "Bearer");

            // Create an instance of the API class
            var apiInstance = new CampaignsApi();
            var campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d;  // UUID |  (default to null)
            var campaignsModeUpdateRequest = new CampaignsModeUpdateRequest(); // CampaignsModeUpdateRequest | 

            try {
                // Update campaign execution mode
                campaigns_mode_update_200_response result = apiInstance.campaignsModeUpdate(campaignId, campaignsModeUpdateRequest);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling CampaignsApi.campaignsModeUpdate: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure API key authorization: cookieAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('domainflow_session', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('domainflow_session', 'Bearer');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\CampaignsApi();
$campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 
$campaignsModeUpdateRequest = ; // CampaignsModeUpdateRequest | 

try {
    $result = $api_instance->campaignsModeUpdate($campaignId, $campaignsModeUpdateRequest);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling CampaignsApi->campaignsModeUpdate: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::CampaignsApi;

# Configure API key authorization: cookieAuth
$WWW::OPenAPIClient::Configuration::api_key->{'domainflow_session'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'domainflow_session'} = "Bearer";

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::CampaignsApi->new();
my $campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; # UUID | 
my $campaignsModeUpdateRequest = WWW::OPenAPIClient::Object::CampaignsModeUpdateRequest->new(); # CampaignsModeUpdateRequest | 

eval {
    my $result = $api_instance->campaignsModeUpdate(campaignId => $campaignId, campaignsModeUpdateRequest => $campaignsModeUpdateRequest);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling CampaignsApi->campaignsModeUpdate: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure API key authorization: cookieAuth
openapi_client.configuration.api_key['domainflow_session'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['domainflow_session'] = 'Bearer'

# Create an instance of the API class
api_instance = openapi_client.CampaignsApi()
campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d # UUID |  (default to null)
campaignsModeUpdateRequest =  # CampaignsModeUpdateRequest | 

try:
    # Update campaign execution mode
    api_response = api_instance.campaigns_mode_update(campaignId, campaignsModeUpdateRequest)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling CampaignsApi->campaignsModeUpdate: %s\n" % e)
extern crate CampaignsApi;

pub fn main() {
    let campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID
    let campaignsModeUpdateRequest = ; // CampaignsModeUpdateRequest

    let mut context = CampaignsApi::Context::default();
    let result = client.campaignsModeUpdate(campaignId, campaignsModeUpdateRequest, &context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Path parameters
Name Description
campaignId*
UUID (uuid)
Required
Body parameters
Name Description
campaignsModeUpdateRequest *

Responses


campaignsPhaseConfigsList

List stored phase configurations for a campaign


/campaigns/{campaignId}/configs

Usage and SDK Samples

curl -X GET \
 \
 -H "Accept: application/json" \
 "https://api.domainflow.dev/api/v2/campaigns/{campaignId}/configs"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.CampaignsApi;

import java.io.File;
import java.util.*;

public class CampaignsApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure API key authorization: cookieAuth
        ApiKeyAuth cookieAuth = (ApiKeyAuth) defaultClient.getAuthentication("cookieAuth");
        cookieAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //cookieAuth.setApiKeyPrefix("Token");

        // Create an instance of the API class
        CampaignsApi apiInstance = new CampaignsApi();
        UUID campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 

        try {
            campaigns_phase_configs_list_200_response result = apiInstance.campaignsPhaseConfigsList(campaignId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling CampaignsApi#campaignsPhaseConfigsList");
            e.printStackTrace();
        }
    }
}
import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final UUID campaignId = new UUID(); // UUID | 

try {
    final result = await api_instance.campaignsPhaseConfigsList(campaignId);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->campaignsPhaseConfigsList: $e\n');
}

import org.openapitools.client.api.CampaignsApi;

public class CampaignsApiExample {
    public static void main(String[] args) {
        CampaignsApi apiInstance = new CampaignsApi();
        UUID campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 

        try {
            campaigns_phase_configs_list_200_response result = apiInstance.campaignsPhaseConfigsList(campaignId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling CampaignsApi#campaignsPhaseConfigsList");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: cookieAuth)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"domainflow_session"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"domainflow_session"];


// Create an instance of the API class
CampaignsApi *apiInstance = [[CampaignsApi alloc] init];
UUID *campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; //  (default to null)

// List stored phase configurations for a campaign
[apiInstance campaignsPhaseConfigsListWith:campaignId
              completionHandler: ^(campaigns_phase_configs_list_200_response output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var DomainFlowApi = require('domain_flow_api');
var defaultClient = DomainFlowApi.ApiClient.instance;

// Configure API key authorization: cookieAuth
var cookieAuth = defaultClient.authentications['cookieAuth'];
cookieAuth.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//cookieAuth.apiKeyPrefix['domainflow_session'] = "Token";

// Create an instance of the API class
var api = new DomainFlowApi.CampaignsApi()
var campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // {UUID} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.campaignsPhaseConfigsList(campaignId, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class campaignsPhaseConfigsListExample
    {
        public void main()
        {
            // Configure API key authorization: cookieAuth
            Configuration.Default.ApiKey.Add("domainflow_session", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("domainflow_session", "Bearer");

            // Create an instance of the API class
            var apiInstance = new CampaignsApi();
            var campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d;  // UUID |  (default to null)

            try {
                // List stored phase configurations for a campaign
                campaigns_phase_configs_list_200_response result = apiInstance.campaignsPhaseConfigsList(campaignId);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling CampaignsApi.campaignsPhaseConfigsList: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure API key authorization: cookieAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('domainflow_session', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('domainflow_session', 'Bearer');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\CampaignsApi();
$campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 

try {
    $result = $api_instance->campaignsPhaseConfigsList($campaignId);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling CampaignsApi->campaignsPhaseConfigsList: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::CampaignsApi;

# Configure API key authorization: cookieAuth
$WWW::OPenAPIClient::Configuration::api_key->{'domainflow_session'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'domainflow_session'} = "Bearer";

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::CampaignsApi->new();
my $campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; # UUID | 

eval {
    my $result = $api_instance->campaignsPhaseConfigsList(campaignId => $campaignId);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling CampaignsApi->campaignsPhaseConfigsList: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure API key authorization: cookieAuth
openapi_client.configuration.api_key['domainflow_session'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['domainflow_session'] = 'Bearer'

# Create an instance of the API class
api_instance = openapi_client.CampaignsApi()
campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d # UUID |  (default to null)

try:
    # List stored phase configurations for a campaign
    api_response = api_instance.campaigns_phase_configs_list(campaignId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling CampaignsApi->campaignsPhaseConfigsList: %s\n" % e)
extern crate CampaignsApi;

pub fn main() {
    let campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID

    let mut context = CampaignsApi::Context::default();
    let result = client.campaignsPhaseConfigsList(campaignId, &context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Path parameters
Name Description
campaignId*
UUID (uuid)
Required

Responses


campaignsPhaseConfigure

Configure campaign phase


/campaigns/{campaignId}/phases/{phase}/configure

Usage and SDK Samples

curl -X POST \
 \
 -H "Accept: application/json" \
 -H "Content-Type: application/json" \
 "https://api.domainflow.dev/api/v2/campaigns/{campaignId}/phases/{phase}/configure" \
 -d '{
  "keywordSetIds" : [ "046b6c7f-0b8a-43b9-b35d-6489e6daee91", "046b6c7f-0b8a-43b9-b35d-6489e6daee91" ],
  "proxyPoolId" : "046b6c7f-0b8a-43b9-b35d-6489e6daee91",
  "configuration" : {
    "key" : ""
  },
  "personaIds" : {
    "httpPersonaId" : "046b6c7f-0b8a-43b9-b35d-6489e6daee91",
    "dnsPersonaId" : "046b6c7f-0b8a-43b9-b35d-6489e6daee91"
  }
}'
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.CampaignsApi;

import java.io.File;
import java.util.*;

public class CampaignsApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure API key authorization: cookieAuth
        ApiKeyAuth cookieAuth = (ApiKeyAuth) defaultClient.getAuthentication("cookieAuth");
        cookieAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //cookieAuth.setApiKeyPrefix("Token");

        // Create an instance of the API class
        CampaignsApi apiInstance = new CampaignsApi();
        UUID campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 
        String phase = phase_example; // String | 
        PhaseConfigurationRequest phaseConfigurationRequest = ; // PhaseConfigurationRequest | 

        try {
            campaigns_phase_status_200_response result = apiInstance.campaignsPhaseConfigure(campaignId, phase, phaseConfigurationRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling CampaignsApi#campaignsPhaseConfigure");
            e.printStackTrace();
        }
    }
}
import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final UUID campaignId = new UUID(); // UUID | 
final String phase = new String(); // String | 
final PhaseConfigurationRequest phaseConfigurationRequest = new PhaseConfigurationRequest(); // PhaseConfigurationRequest | 

try {
    final result = await api_instance.campaignsPhaseConfigure(campaignId, phase, phaseConfigurationRequest);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->campaignsPhaseConfigure: $e\n');
}

import org.openapitools.client.api.CampaignsApi;

public class CampaignsApiExample {
    public static void main(String[] args) {
        CampaignsApi apiInstance = new CampaignsApi();
        UUID campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 
        String phase = phase_example; // String | 
        PhaseConfigurationRequest phaseConfigurationRequest = ; // PhaseConfigurationRequest | 

        try {
            campaigns_phase_status_200_response result = apiInstance.campaignsPhaseConfigure(campaignId, phase, phaseConfigurationRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling CampaignsApi#campaignsPhaseConfigure");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: cookieAuth)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"domainflow_session"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"domainflow_session"];


// Create an instance of the API class
CampaignsApi *apiInstance = [[CampaignsApi alloc] init];
UUID *campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; //  (default to null)
String *phase = phase_example; //  (default to null)
PhaseConfigurationRequest *phaseConfigurationRequest = ; // 

// Configure campaign phase
[apiInstance campaignsPhaseConfigureWith:campaignId
    phase:phase
    phaseConfigurationRequest:phaseConfigurationRequest
              completionHandler: ^(campaigns_phase_status_200_response output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var DomainFlowApi = require('domain_flow_api');
var defaultClient = DomainFlowApi.ApiClient.instance;

// Configure API key authorization: cookieAuth
var cookieAuth = defaultClient.authentications['cookieAuth'];
cookieAuth.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//cookieAuth.apiKeyPrefix['domainflow_session'] = "Token";

// Create an instance of the API class
var api = new DomainFlowApi.CampaignsApi()
var campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // {UUID} 
var phase = phase_example; // {String} 
var phaseConfigurationRequest = ; // {PhaseConfigurationRequest} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.campaignsPhaseConfigure(campaignId, phase, phaseConfigurationRequest, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class campaignsPhaseConfigureExample
    {
        public void main()
        {
            // Configure API key authorization: cookieAuth
            Configuration.Default.ApiKey.Add("domainflow_session", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("domainflow_session", "Bearer");

            // Create an instance of the API class
            var apiInstance = new CampaignsApi();
            var campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d;  // UUID |  (default to null)
            var phase = phase_example;  // String |  (default to null)
            var phaseConfigurationRequest = new PhaseConfigurationRequest(); // PhaseConfigurationRequest | 

            try {
                // Configure campaign phase
                campaigns_phase_status_200_response result = apiInstance.campaignsPhaseConfigure(campaignId, phase, phaseConfigurationRequest);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling CampaignsApi.campaignsPhaseConfigure: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure API key authorization: cookieAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('domainflow_session', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('domainflow_session', 'Bearer');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\CampaignsApi();
$campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 
$phase = phase_example; // String | 
$phaseConfigurationRequest = ; // PhaseConfigurationRequest | 

try {
    $result = $api_instance->campaignsPhaseConfigure($campaignId, $phase, $phaseConfigurationRequest);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling CampaignsApi->campaignsPhaseConfigure: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::CampaignsApi;

# Configure API key authorization: cookieAuth
$WWW::OPenAPIClient::Configuration::api_key->{'domainflow_session'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'domainflow_session'} = "Bearer";

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::CampaignsApi->new();
my $campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; # UUID | 
my $phase = phase_example; # String | 
my $phaseConfigurationRequest = WWW::OPenAPIClient::Object::PhaseConfigurationRequest->new(); # PhaseConfigurationRequest | 

eval {
    my $result = $api_instance->campaignsPhaseConfigure(campaignId => $campaignId, phase => $phase, phaseConfigurationRequest => $phaseConfigurationRequest);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling CampaignsApi->campaignsPhaseConfigure: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure API key authorization: cookieAuth
openapi_client.configuration.api_key['domainflow_session'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['domainflow_session'] = 'Bearer'

# Create an instance of the API class
api_instance = openapi_client.CampaignsApi()
campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d # UUID |  (default to null)
phase = phase_example # String |  (default to null)
phaseConfigurationRequest =  # PhaseConfigurationRequest | 

try:
    # Configure campaign phase
    api_response = api_instance.campaigns_phase_configure(campaignId, phase, phaseConfigurationRequest)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling CampaignsApi->campaignsPhaseConfigure: %s\n" % e)
extern crate CampaignsApi;

pub fn main() {
    let campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID
    let phase = phase_example; // String
    let phaseConfigurationRequest = ; // PhaseConfigurationRequest

    let mut context = CampaignsApi::Context::default();
    let result = client.campaignsPhaseConfigure(campaignId, phase, phaseConfigurationRequest, &context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Path parameters
Name Description
campaignId*
UUID (uuid)
Required
phase*
String
Required
Body parameters
Name Description
phaseConfigurationRequest *

Responses


campaignsPhaseExecutionDelete

Delete phase execution by phase type


/campaigns/{campaignId}/phase-executions/{phaseType}

Usage and SDK Samples

curl -X DELETE \
 \
 -H "Accept: application/json" \
 "https://api.domainflow.dev/api/v2/campaigns/{campaignId}/phase-executions/{phaseType}"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.CampaignsApi;

import java.io.File;
import java.util.*;

public class CampaignsApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure API key authorization: cookieAuth
        ApiKeyAuth cookieAuth = (ApiKeyAuth) defaultClient.getAuthentication("cookieAuth");
        cookieAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //cookieAuth.setApiKeyPrefix("Token");

        // Create an instance of the API class
        CampaignsApi apiInstance = new CampaignsApi();
        UUID campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 
        String phaseType = phaseType_example; // String | 

        try {
            apiInstance.campaignsPhaseExecutionDelete(campaignId, phaseType);
        } catch (ApiException e) {
            System.err.println("Exception when calling CampaignsApi#campaignsPhaseExecutionDelete");
            e.printStackTrace();
        }
    }
}
import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final UUID campaignId = new UUID(); // UUID | 
final String phaseType = new String(); // String | 

try {
    final result = await api_instance.campaignsPhaseExecutionDelete(campaignId, phaseType);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->campaignsPhaseExecutionDelete: $e\n');
}

import org.openapitools.client.api.CampaignsApi;

public class CampaignsApiExample {
    public static void main(String[] args) {
        CampaignsApi apiInstance = new CampaignsApi();
        UUID campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 
        String phaseType = phaseType_example; // String | 

        try {
            apiInstance.campaignsPhaseExecutionDelete(campaignId, phaseType);
        } catch (ApiException e) {
            System.err.println("Exception when calling CampaignsApi#campaignsPhaseExecutionDelete");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: cookieAuth)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"domainflow_session"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"domainflow_session"];


// Create an instance of the API class
CampaignsApi *apiInstance = [[CampaignsApi alloc] init];
UUID *campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; //  (default to null)
String *phaseType = phaseType_example; //  (default to null)

// Delete phase execution by phase type
[apiInstance campaignsPhaseExecutionDeleteWith:campaignId
    phaseType:phaseType
              completionHandler: ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var DomainFlowApi = require('domain_flow_api');
var defaultClient = DomainFlowApi.ApiClient.instance;

// Configure API key authorization: cookieAuth
var cookieAuth = defaultClient.authentications['cookieAuth'];
cookieAuth.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//cookieAuth.apiKeyPrefix['domainflow_session'] = "Token";

// Create an instance of the API class
var api = new DomainFlowApi.CampaignsApi()
var campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // {UUID} 
var phaseType = phaseType_example; // {String} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.campaignsPhaseExecutionDelete(campaignId, phaseType, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class campaignsPhaseExecutionDeleteExample
    {
        public void main()
        {
            // Configure API key authorization: cookieAuth
            Configuration.Default.ApiKey.Add("domainflow_session", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("domainflow_session", "Bearer");

            // Create an instance of the API class
            var apiInstance = new CampaignsApi();
            var campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d;  // UUID |  (default to null)
            var phaseType = phaseType_example;  // String |  (default to null)

            try {
                // Delete phase execution by phase type
                apiInstance.campaignsPhaseExecutionDelete(campaignId, phaseType);
            } catch (Exception e) {
                Debug.Print("Exception when calling CampaignsApi.campaignsPhaseExecutionDelete: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure API key authorization: cookieAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('domainflow_session', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('domainflow_session', 'Bearer');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\CampaignsApi();
$campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 
$phaseType = phaseType_example; // String | 

try {
    $api_instance->campaignsPhaseExecutionDelete($campaignId, $phaseType);
} catch (Exception $e) {
    echo 'Exception when calling CampaignsApi->campaignsPhaseExecutionDelete: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::CampaignsApi;

# Configure API key authorization: cookieAuth
$WWW::OPenAPIClient::Configuration::api_key->{'domainflow_session'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'domainflow_session'} = "Bearer";

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::CampaignsApi->new();
my $campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; # UUID | 
my $phaseType = phaseType_example; # String | 

eval {
    $api_instance->campaignsPhaseExecutionDelete(campaignId => $campaignId, phaseType => $phaseType);
};
if ($@) {
    warn "Exception when calling CampaignsApi->campaignsPhaseExecutionDelete: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure API key authorization: cookieAuth
openapi_client.configuration.api_key['domainflow_session'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['domainflow_session'] = 'Bearer'

# Create an instance of the API class
api_instance = openapi_client.CampaignsApi()
campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d # UUID |  (default to null)
phaseType = phaseType_example # String |  (default to null)

try:
    # Delete phase execution by phase type
    api_instance.campaigns_phase_execution_delete(campaignId, phaseType)
except ApiException as e:
    print("Exception when calling CampaignsApi->campaignsPhaseExecutionDelete: %s\n" % e)
extern crate CampaignsApi;

pub fn main() {
    let campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID
    let phaseType = phaseType_example; // String

    let mut context = CampaignsApi::Context::default();
    let result = client.campaignsPhaseExecutionDelete(campaignId, phaseType, &context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Path parameters
Name Description
campaignId*
UUID (uuid)
Required
phaseType*
String
Required

Responses


campaignsPhaseExecutionGet

Get phase execution by phase type


/campaigns/{campaignId}/phase-executions/{phaseType}

Usage and SDK Samples

curl -X GET \
 \
 -H "Accept: application/json" \
 "https://api.domainflow.dev/api/v2/campaigns/{campaignId}/phase-executions/{phaseType}"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.CampaignsApi;

import java.io.File;
import java.util.*;

public class CampaignsApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure API key authorization: cookieAuth
        ApiKeyAuth cookieAuth = (ApiKeyAuth) defaultClient.getAuthentication("cookieAuth");
        cookieAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //cookieAuth.setApiKeyPrefix("Token");

        // Create an instance of the API class
        CampaignsApi apiInstance = new CampaignsApi();
        UUID campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 
        String phaseType = phaseType_example; // String | 

        try {
            campaigns_phase_execution_get_200_response result = apiInstance.campaignsPhaseExecutionGet(campaignId, phaseType);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling CampaignsApi#campaignsPhaseExecutionGet");
            e.printStackTrace();
        }
    }
}
import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final UUID campaignId = new UUID(); // UUID | 
final String phaseType = new String(); // String | 

try {
    final result = await api_instance.campaignsPhaseExecutionGet(campaignId, phaseType);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->campaignsPhaseExecutionGet: $e\n');
}

import org.openapitools.client.api.CampaignsApi;

public class CampaignsApiExample {
    public static void main(String[] args) {
        CampaignsApi apiInstance = new CampaignsApi();
        UUID campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 
        String phaseType = phaseType_example; // String | 

        try {
            campaigns_phase_execution_get_200_response result = apiInstance.campaignsPhaseExecutionGet(campaignId, phaseType);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling CampaignsApi#campaignsPhaseExecutionGet");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: cookieAuth)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"domainflow_session"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"domainflow_session"];


// Create an instance of the API class
CampaignsApi *apiInstance = [[CampaignsApi alloc] init];
UUID *campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; //  (default to null)
String *phaseType = phaseType_example; //  (default to null)

// Get phase execution by phase type
[apiInstance campaignsPhaseExecutionGetWith:campaignId
    phaseType:phaseType
              completionHandler: ^(campaigns_phase_execution_get_200_response output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var DomainFlowApi = require('domain_flow_api');
var defaultClient = DomainFlowApi.ApiClient.instance;

// Configure API key authorization: cookieAuth
var cookieAuth = defaultClient.authentications['cookieAuth'];
cookieAuth.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//cookieAuth.apiKeyPrefix['domainflow_session'] = "Token";

// Create an instance of the API class
var api = new DomainFlowApi.CampaignsApi()
var campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // {UUID} 
var phaseType = phaseType_example; // {String} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.campaignsPhaseExecutionGet(campaignId, phaseType, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class campaignsPhaseExecutionGetExample
    {
        public void main()
        {
            // Configure API key authorization: cookieAuth
            Configuration.Default.ApiKey.Add("domainflow_session", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("domainflow_session", "Bearer");

            // Create an instance of the API class
            var apiInstance = new CampaignsApi();
            var campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d;  // UUID |  (default to null)
            var phaseType = phaseType_example;  // String |  (default to null)

            try {
                // Get phase execution by phase type
                campaigns_phase_execution_get_200_response result = apiInstance.campaignsPhaseExecutionGet(campaignId, phaseType);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling CampaignsApi.campaignsPhaseExecutionGet: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure API key authorization: cookieAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('domainflow_session', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('domainflow_session', 'Bearer');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\CampaignsApi();
$campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 
$phaseType = phaseType_example; // String | 

try {
    $result = $api_instance->campaignsPhaseExecutionGet($campaignId, $phaseType);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling CampaignsApi->campaignsPhaseExecutionGet: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::CampaignsApi;

# Configure API key authorization: cookieAuth
$WWW::OPenAPIClient::Configuration::api_key->{'domainflow_session'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'domainflow_session'} = "Bearer";

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::CampaignsApi->new();
my $campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; # UUID | 
my $phaseType = phaseType_example; # String | 

eval {
    my $result = $api_instance->campaignsPhaseExecutionGet(campaignId => $campaignId, phaseType => $phaseType);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling CampaignsApi->campaignsPhaseExecutionGet: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure API key authorization: cookieAuth
openapi_client.configuration.api_key['domainflow_session'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['domainflow_session'] = 'Bearer'

# Create an instance of the API class
api_instance = openapi_client.CampaignsApi()
campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d # UUID |  (default to null)
phaseType = phaseType_example # String |  (default to null)

try:
    # Get phase execution by phase type
    api_response = api_instance.campaigns_phase_execution_get(campaignId, phaseType)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling CampaignsApi->campaignsPhaseExecutionGet: %s\n" % e)
extern crate CampaignsApi;

pub fn main() {
    let campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID
    let phaseType = phaseType_example; // String

    let mut context = CampaignsApi::Context::default();
    let result = client.campaignsPhaseExecutionGet(campaignId, phaseType, &context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Path parameters
Name Description
campaignId*
UUID (uuid)
Required
phaseType*
String
Required

Responses


campaignsPhaseExecutionPut

Update phase execution by phase type


/campaigns/{campaignId}/phase-executions/{phaseType}

Usage and SDK Samples

curl -X PUT \
 \
 -H "Accept: application/json" \
 -H "Content-Type: application/json" \
 "https://api.domainflow.dev/api/v2/campaigns/{campaignId}/phase-executions/{phaseType}" \
 -d '{
  "completedAt" : "2000-01-23T04:56:07.000+00:00",
  "totalItems" : 6,
  "configuration" : {
    "key" : ""
  },
  "startedAt" : "2000-01-23T04:56:07.000+00:00",
  "pausedAt" : "2000-01-23T04:56:07.000+00:00",
  "failedAt" : "2000-01-23T04:56:07.000+00:00",
  "progressPercentage" : 0.8008282,
  "failedItems" : 5,
  "metrics" : {
    "key" : ""
  },
  "processedItems" : 1,
  "status" : "not_started",
  "successfulItems" : 5,
  "errorDetails" : {
    "key" : ""
  }
}'
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.CampaignsApi;

import java.io.File;
import java.util.*;

public class CampaignsApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure API key authorization: cookieAuth
        ApiKeyAuth cookieAuth = (ApiKeyAuth) defaultClient.getAuthentication("cookieAuth");
        cookieAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //cookieAuth.setApiKeyPrefix("Token");

        // Create an instance of the API class
        CampaignsApi apiInstance = new CampaignsApi();
        UUID campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 
        String phaseType = phaseType_example; // String | 
        PhaseExecutionUpdate phaseExecutionUpdate = ; // PhaseExecutionUpdate | 

        try {
            campaigns_phase_execution_get_200_response result = apiInstance.campaignsPhaseExecutionPut(campaignId, phaseType, phaseExecutionUpdate);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling CampaignsApi#campaignsPhaseExecutionPut");
            e.printStackTrace();
        }
    }
}
import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final UUID campaignId = new UUID(); // UUID | 
final String phaseType = new String(); // String | 
final PhaseExecutionUpdate phaseExecutionUpdate = new PhaseExecutionUpdate(); // PhaseExecutionUpdate | 

try {
    final result = await api_instance.campaignsPhaseExecutionPut(campaignId, phaseType, phaseExecutionUpdate);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->campaignsPhaseExecutionPut: $e\n');
}

import org.openapitools.client.api.CampaignsApi;

public class CampaignsApiExample {
    public static void main(String[] args) {
        CampaignsApi apiInstance = new CampaignsApi();
        UUID campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 
        String phaseType = phaseType_example; // String | 
        PhaseExecutionUpdate phaseExecutionUpdate = ; // PhaseExecutionUpdate | 

        try {
            campaigns_phase_execution_get_200_response result = apiInstance.campaignsPhaseExecutionPut(campaignId, phaseType, phaseExecutionUpdate);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling CampaignsApi#campaignsPhaseExecutionPut");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: cookieAuth)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"domainflow_session"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"domainflow_session"];


// Create an instance of the API class
CampaignsApi *apiInstance = [[CampaignsApi alloc] init];
UUID *campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; //  (default to null)
String *phaseType = phaseType_example; //  (default to null)
PhaseExecutionUpdate *phaseExecutionUpdate = ; // 

// Update phase execution by phase type
[apiInstance campaignsPhaseExecutionPutWith:campaignId
    phaseType:phaseType
    phaseExecutionUpdate:phaseExecutionUpdate
              completionHandler: ^(campaigns_phase_execution_get_200_response output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var DomainFlowApi = require('domain_flow_api');
var defaultClient = DomainFlowApi.ApiClient.instance;

// Configure API key authorization: cookieAuth
var cookieAuth = defaultClient.authentications['cookieAuth'];
cookieAuth.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//cookieAuth.apiKeyPrefix['domainflow_session'] = "Token";

// Create an instance of the API class
var api = new DomainFlowApi.CampaignsApi()
var campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // {UUID} 
var phaseType = phaseType_example; // {String} 
var phaseExecutionUpdate = ; // {PhaseExecutionUpdate} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.campaignsPhaseExecutionPut(campaignId, phaseType, phaseExecutionUpdate, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class campaignsPhaseExecutionPutExample
    {
        public void main()
        {
            // Configure API key authorization: cookieAuth
            Configuration.Default.ApiKey.Add("domainflow_session", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("domainflow_session", "Bearer");

            // Create an instance of the API class
            var apiInstance = new CampaignsApi();
            var campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d;  // UUID |  (default to null)
            var phaseType = phaseType_example;  // String |  (default to null)
            var phaseExecutionUpdate = new PhaseExecutionUpdate(); // PhaseExecutionUpdate | 

            try {
                // Update phase execution by phase type
                campaigns_phase_execution_get_200_response result = apiInstance.campaignsPhaseExecutionPut(campaignId, phaseType, phaseExecutionUpdate);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling CampaignsApi.campaignsPhaseExecutionPut: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure API key authorization: cookieAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('domainflow_session', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('domainflow_session', 'Bearer');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\CampaignsApi();
$campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 
$phaseType = phaseType_example; // String | 
$phaseExecutionUpdate = ; // PhaseExecutionUpdate | 

try {
    $result = $api_instance->campaignsPhaseExecutionPut($campaignId, $phaseType, $phaseExecutionUpdate);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling CampaignsApi->campaignsPhaseExecutionPut: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::CampaignsApi;

# Configure API key authorization: cookieAuth
$WWW::OPenAPIClient::Configuration::api_key->{'domainflow_session'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'domainflow_session'} = "Bearer";

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::CampaignsApi->new();
my $campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; # UUID | 
my $phaseType = phaseType_example; # String | 
my $phaseExecutionUpdate = WWW::OPenAPIClient::Object::PhaseExecutionUpdate->new(); # PhaseExecutionUpdate | 

eval {
    my $result = $api_instance->campaignsPhaseExecutionPut(campaignId => $campaignId, phaseType => $phaseType, phaseExecutionUpdate => $phaseExecutionUpdate);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling CampaignsApi->campaignsPhaseExecutionPut: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure API key authorization: cookieAuth
openapi_client.configuration.api_key['domainflow_session'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['domainflow_session'] = 'Bearer'

# Create an instance of the API class
api_instance = openapi_client.CampaignsApi()
campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d # UUID |  (default to null)
phaseType = phaseType_example # String |  (default to null)
phaseExecutionUpdate =  # PhaseExecutionUpdate | 

try:
    # Update phase execution by phase type
    api_response = api_instance.campaigns_phase_execution_put(campaignId, phaseType, phaseExecutionUpdate)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling CampaignsApi->campaignsPhaseExecutionPut: %s\n" % e)
extern crate CampaignsApi;

pub fn main() {
    let campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID
    let phaseType = phaseType_example; // String
    let phaseExecutionUpdate = ; // PhaseExecutionUpdate

    let mut context = CampaignsApi::Context::default();
    let result = client.campaignsPhaseExecutionPut(campaignId, phaseType, phaseExecutionUpdate, &context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Path parameters
Name Description
campaignId*
UUID (uuid)
Required
phaseType*
String
Required
Body parameters
Name Description
phaseExecutionUpdate *

Responses


campaignsPhaseExecutionsList

Get campaign state and phase executions


/campaigns/{campaignId}/phase-executions

Usage and SDK Samples

curl -X GET \
 \
 -H "Accept: application/json" \
 "https://api.domainflow.dev/api/v2/campaigns/{campaignId}/phase-executions"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.CampaignsApi;

import java.io.File;
import java.util.*;

public class CampaignsApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure API key authorization: cookieAuth
        ApiKeyAuth cookieAuth = (ApiKeyAuth) defaultClient.getAuthentication("cookieAuth");
        cookieAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //cookieAuth.setApiKeyPrefix("Token");

        // Create an instance of the API class
        CampaignsApi apiInstance = new CampaignsApi();
        UUID campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 

        try {
            campaigns_phase_executions_list_200_response result = apiInstance.campaignsPhaseExecutionsList(campaignId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling CampaignsApi#campaignsPhaseExecutionsList");
            e.printStackTrace();
        }
    }
}
import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final UUID campaignId = new UUID(); // UUID | 

try {
    final result = await api_instance.campaignsPhaseExecutionsList(campaignId);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->campaignsPhaseExecutionsList: $e\n');
}

import org.openapitools.client.api.CampaignsApi;

public class CampaignsApiExample {
    public static void main(String[] args) {
        CampaignsApi apiInstance = new CampaignsApi();
        UUID campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 

        try {
            campaigns_phase_executions_list_200_response result = apiInstance.campaignsPhaseExecutionsList(campaignId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling CampaignsApi#campaignsPhaseExecutionsList");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: cookieAuth)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"domainflow_session"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"domainflow_session"];


// Create an instance of the API class
CampaignsApi *apiInstance = [[CampaignsApi alloc] init];
UUID *campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; //  (default to null)

// Get campaign state and phase executions
[apiInstance campaignsPhaseExecutionsListWith:campaignId
              completionHandler: ^(campaigns_phase_executions_list_200_response output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var DomainFlowApi = require('domain_flow_api');
var defaultClient = DomainFlowApi.ApiClient.instance;

// Configure API key authorization: cookieAuth
var cookieAuth = defaultClient.authentications['cookieAuth'];
cookieAuth.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//cookieAuth.apiKeyPrefix['domainflow_session'] = "Token";

// Create an instance of the API class
var api = new DomainFlowApi.CampaignsApi()
var campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // {UUID} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.campaignsPhaseExecutionsList(campaignId, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class campaignsPhaseExecutionsListExample
    {
        public void main()
        {
            // Configure API key authorization: cookieAuth
            Configuration.Default.ApiKey.Add("domainflow_session", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("domainflow_session", "Bearer");

            // Create an instance of the API class
            var apiInstance = new CampaignsApi();
            var campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d;  // UUID |  (default to null)

            try {
                // Get campaign state and phase executions
                campaigns_phase_executions_list_200_response result = apiInstance.campaignsPhaseExecutionsList(campaignId);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling CampaignsApi.campaignsPhaseExecutionsList: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure API key authorization: cookieAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('domainflow_session', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('domainflow_session', 'Bearer');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\CampaignsApi();
$campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 

try {
    $result = $api_instance->campaignsPhaseExecutionsList($campaignId);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling CampaignsApi->campaignsPhaseExecutionsList: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::CampaignsApi;

# Configure API key authorization: cookieAuth
$WWW::OPenAPIClient::Configuration::api_key->{'domainflow_session'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'domainflow_session'} = "Bearer";

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::CampaignsApi->new();
my $campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; # UUID | 

eval {
    my $result = $api_instance->campaignsPhaseExecutionsList(campaignId => $campaignId);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling CampaignsApi->campaignsPhaseExecutionsList: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure API key authorization: cookieAuth
openapi_client.configuration.api_key['domainflow_session'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['domainflow_session'] = 'Bearer'

# Create an instance of the API class
api_instance = openapi_client.CampaignsApi()
campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d # UUID |  (default to null)

try:
    # Get campaign state and phase executions
    api_response = api_instance.campaigns_phase_executions_list(campaignId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling CampaignsApi->campaignsPhaseExecutionsList: %s\n" % e)
extern crate CampaignsApi;

pub fn main() {
    let campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID

    let mut context = CampaignsApi::Context::default();
    let result = client.campaignsPhaseExecutionsList(campaignId, &context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Path parameters
Name Description
campaignId*
UUID (uuid)
Required

Responses


campaignsPhaseStart

Start campaign phase


/campaigns/{campaignId}/phases/{phase}/start

Usage and SDK Samples

curl -X POST \
 \
 -H "Accept: application/json" \
 "https://api.domainflow.dev/api/v2/campaigns/{campaignId}/phases/{phase}/start"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.CampaignsApi;

import java.io.File;
import java.util.*;

public class CampaignsApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure API key authorization: cookieAuth
        ApiKeyAuth cookieAuth = (ApiKeyAuth) defaultClient.getAuthentication("cookieAuth");
        cookieAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //cookieAuth.setApiKeyPrefix("Token");

        // Create an instance of the API class
        CampaignsApi apiInstance = new CampaignsApi();
        UUID campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 
        String phase = phase_example; // String | 

        try {
            campaigns_phase_status_200_response result = apiInstance.campaignsPhaseStart(campaignId, phase);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling CampaignsApi#campaignsPhaseStart");
            e.printStackTrace();
        }
    }
}
import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final UUID campaignId = new UUID(); // UUID | 
final String phase = new String(); // String | 

try {
    final result = await api_instance.campaignsPhaseStart(campaignId, phase);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->campaignsPhaseStart: $e\n');
}

import org.openapitools.client.api.CampaignsApi;

public class CampaignsApiExample {
    public static void main(String[] args) {
        CampaignsApi apiInstance = new CampaignsApi();
        UUID campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 
        String phase = phase_example; // String | 

        try {
            campaigns_phase_status_200_response result = apiInstance.campaignsPhaseStart(campaignId, phase);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling CampaignsApi#campaignsPhaseStart");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: cookieAuth)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"domainflow_session"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"domainflow_session"];


// Create an instance of the API class
CampaignsApi *apiInstance = [[CampaignsApi alloc] init];
UUID *campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; //  (default to null)
String *phase = phase_example; //  (default to null)

// Start campaign phase
[apiInstance campaignsPhaseStartWith:campaignId
    phase:phase
              completionHandler: ^(campaigns_phase_status_200_response output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var DomainFlowApi = require('domain_flow_api');
var defaultClient = DomainFlowApi.ApiClient.instance;

// Configure API key authorization: cookieAuth
var cookieAuth = defaultClient.authentications['cookieAuth'];
cookieAuth.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//cookieAuth.apiKeyPrefix['domainflow_session'] = "Token";

// Create an instance of the API class
var api = new DomainFlowApi.CampaignsApi()
var campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // {UUID} 
var phase = phase_example; // {String} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.campaignsPhaseStart(campaignId, phase, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class campaignsPhaseStartExample
    {
        public void main()
        {
            // Configure API key authorization: cookieAuth
            Configuration.Default.ApiKey.Add("domainflow_session", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("domainflow_session", "Bearer");

            // Create an instance of the API class
            var apiInstance = new CampaignsApi();
            var campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d;  // UUID |  (default to null)
            var phase = phase_example;  // String |  (default to null)

            try {
                // Start campaign phase
                campaigns_phase_status_200_response result = apiInstance.campaignsPhaseStart(campaignId, phase);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling CampaignsApi.campaignsPhaseStart: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure API key authorization: cookieAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('domainflow_session', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('domainflow_session', 'Bearer');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\CampaignsApi();
$campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 
$phase = phase_example; // String | 

try {
    $result = $api_instance->campaignsPhaseStart($campaignId, $phase);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling CampaignsApi->campaignsPhaseStart: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::CampaignsApi;

# Configure API key authorization: cookieAuth
$WWW::OPenAPIClient::Configuration::api_key->{'domainflow_session'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'domainflow_session'} = "Bearer";

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::CampaignsApi->new();
my $campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; # UUID | 
my $phase = phase_example; # String | 

eval {
    my $result = $api_instance->campaignsPhaseStart(campaignId => $campaignId, phase => $phase);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling CampaignsApi->campaignsPhaseStart: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure API key authorization: cookieAuth
openapi_client.configuration.api_key['domainflow_session'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['domainflow_session'] = 'Bearer'

# Create an instance of the API class
api_instance = openapi_client.CampaignsApi()
campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d # UUID |  (default to null)
phase = phase_example # String |  (default to null)

try:
    # Start campaign phase
    api_response = api_instance.campaigns_phase_start(campaignId, phase)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling CampaignsApi->campaignsPhaseStart: %s\n" % e)
extern crate CampaignsApi;

pub fn main() {
    let campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID
    let phase = phase_example; // String

    let mut context = CampaignsApi::Context::default();
    let result = client.campaignsPhaseStart(campaignId, phase, &context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Path parameters
Name Description
campaignId*
UUID (uuid)
Required
phase*
String
Required

Responses


campaignsPhaseStatus

Get phase status


/campaigns/{campaignId}/phases/{phase}/status

Usage and SDK Samples

curl -X GET \
 \
 -H "Accept: application/json" \
 "https://api.domainflow.dev/api/v2/campaigns/{campaignId}/phases/{phase}/status"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.CampaignsApi;

import java.io.File;
import java.util.*;

public class CampaignsApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure API key authorization: cookieAuth
        ApiKeyAuth cookieAuth = (ApiKeyAuth) defaultClient.getAuthentication("cookieAuth");
        cookieAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //cookieAuth.setApiKeyPrefix("Token");

        // Create an instance of the API class
        CampaignsApi apiInstance = new CampaignsApi();
        UUID campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 
        String phase = phase_example; // String | 

        try {
            campaigns_phase_status_200_response result = apiInstance.campaignsPhaseStatus(campaignId, phase);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling CampaignsApi#campaignsPhaseStatus");
            e.printStackTrace();
        }
    }
}
import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final UUID campaignId = new UUID(); // UUID | 
final String phase = new String(); // String | 

try {
    final result = await api_instance.campaignsPhaseStatus(campaignId, phase);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->campaignsPhaseStatus: $e\n');
}

import org.openapitools.client.api.CampaignsApi;

public class CampaignsApiExample {
    public static void main(String[] args) {
        CampaignsApi apiInstance = new CampaignsApi();
        UUID campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 
        String phase = phase_example; // String | 

        try {
            campaigns_phase_status_200_response result = apiInstance.campaignsPhaseStatus(campaignId, phase);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling CampaignsApi#campaignsPhaseStatus");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: cookieAuth)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"domainflow_session"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"domainflow_session"];


// Create an instance of the API class
CampaignsApi *apiInstance = [[CampaignsApi alloc] init];
UUID *campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; //  (default to null)
String *phase = phase_example; //  (default to null)

// Get phase status
[apiInstance campaignsPhaseStatusWith:campaignId
    phase:phase
              completionHandler: ^(campaigns_phase_status_200_response output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var DomainFlowApi = require('domain_flow_api');
var defaultClient = DomainFlowApi.ApiClient.instance;

// Configure API key authorization: cookieAuth
var cookieAuth = defaultClient.authentications['cookieAuth'];
cookieAuth.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//cookieAuth.apiKeyPrefix['domainflow_session'] = "Token";

// Create an instance of the API class
var api = new DomainFlowApi.CampaignsApi()
var campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // {UUID} 
var phase = phase_example; // {String} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.campaignsPhaseStatus(campaignId, phase, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class campaignsPhaseStatusExample
    {
        public void main()
        {
            // Configure API key authorization: cookieAuth
            Configuration.Default.ApiKey.Add("domainflow_session", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("domainflow_session", "Bearer");

            // Create an instance of the API class
            var apiInstance = new CampaignsApi();
            var campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d;  // UUID |  (default to null)
            var phase = phase_example;  // String |  (default to null)

            try {
                // Get phase status
                campaigns_phase_status_200_response result = apiInstance.campaignsPhaseStatus(campaignId, phase);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling CampaignsApi.campaignsPhaseStatus: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure API key authorization: cookieAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('domainflow_session', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('domainflow_session', 'Bearer');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\CampaignsApi();
$campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 
$phase = phase_example; // String | 

try {
    $result = $api_instance->campaignsPhaseStatus($campaignId, $phase);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling CampaignsApi->campaignsPhaseStatus: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::CampaignsApi;

# Configure API key authorization: cookieAuth
$WWW::OPenAPIClient::Configuration::api_key->{'domainflow_session'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'domainflow_session'} = "Bearer";

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::CampaignsApi->new();
my $campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; # UUID | 
my $phase = phase_example; # String | 

eval {
    my $result = $api_instance->campaignsPhaseStatus(campaignId => $campaignId, phase => $phase);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling CampaignsApi->campaignsPhaseStatus: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure API key authorization: cookieAuth
openapi_client.configuration.api_key['domainflow_session'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['domainflow_session'] = 'Bearer'

# Create an instance of the API class
api_instance = openapi_client.CampaignsApi()
campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d # UUID |  (default to null)
phase = phase_example # String |  (default to null)

try:
    # Get phase status
    api_response = api_instance.campaigns_phase_status(campaignId, phase)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling CampaignsApi->campaignsPhaseStatus: %s\n" % e)
extern crate CampaignsApi;

pub fn main() {
    let campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID
    let phase = phase_example; // String

    let mut context = CampaignsApi::Context::default();
    let result = client.campaignsPhaseStatus(campaignId, phase, &context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Path parameters
Name Description
campaignId*
UUID (uuid)
Required
phase*
String
Required

Responses


campaignsPhaseStop

Stop campaign phase


/campaigns/{campaignId}/phases/{phase}/stop

Usage and SDK Samples

curl -X POST \
 \
 -H "Accept: application/json" \
 "https://api.domainflow.dev/api/v2/campaigns/{campaignId}/phases/{phase}/stop"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.CampaignsApi;

import java.io.File;
import java.util.*;

public class CampaignsApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure API key authorization: cookieAuth
        ApiKeyAuth cookieAuth = (ApiKeyAuth) defaultClient.getAuthentication("cookieAuth");
        cookieAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //cookieAuth.setApiKeyPrefix("Token");

        // Create an instance of the API class
        CampaignsApi apiInstance = new CampaignsApi();
        UUID campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 
        String phase = phase_example; // String | 

        try {
            campaigns_phase_status_200_response result = apiInstance.campaignsPhaseStop(campaignId, phase);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling CampaignsApi#campaignsPhaseStop");
            e.printStackTrace();
        }
    }
}
import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final UUID campaignId = new UUID(); // UUID | 
final String phase = new String(); // String | 

try {
    final result = await api_instance.campaignsPhaseStop(campaignId, phase);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->campaignsPhaseStop: $e\n');
}

import org.openapitools.client.api.CampaignsApi;

public class CampaignsApiExample {
    public static void main(String[] args) {
        CampaignsApi apiInstance = new CampaignsApi();
        UUID campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 
        String phase = phase_example; // String | 

        try {
            campaigns_phase_status_200_response result = apiInstance.campaignsPhaseStop(campaignId, phase);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling CampaignsApi#campaignsPhaseStop");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: cookieAuth)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"domainflow_session"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"domainflow_session"];


// Create an instance of the API class
CampaignsApi *apiInstance = [[CampaignsApi alloc] init];
UUID *campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; //  (default to null)
String *phase = phase_example; //  (default to null)

// Stop campaign phase
[apiInstance campaignsPhaseStopWith:campaignId
    phase:phase
              completionHandler: ^(campaigns_phase_status_200_response output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var DomainFlowApi = require('domain_flow_api');
var defaultClient = DomainFlowApi.ApiClient.instance;

// Configure API key authorization: cookieAuth
var cookieAuth = defaultClient.authentications['cookieAuth'];
cookieAuth.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//cookieAuth.apiKeyPrefix['domainflow_session'] = "Token";

// Create an instance of the API class
var api = new DomainFlowApi.CampaignsApi()
var campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // {UUID} 
var phase = phase_example; // {String} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.campaignsPhaseStop(campaignId, phase, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class campaignsPhaseStopExample
    {
        public void main()
        {
            // Configure API key authorization: cookieAuth
            Configuration.Default.ApiKey.Add("domainflow_session", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("domainflow_session", "Bearer");

            // Create an instance of the API class
            var apiInstance = new CampaignsApi();
            var campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d;  // UUID |  (default to null)
            var phase = phase_example;  // String |  (default to null)

            try {
                // Stop campaign phase
                campaigns_phase_status_200_response result = apiInstance.campaignsPhaseStop(campaignId, phase);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling CampaignsApi.campaignsPhaseStop: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure API key authorization: cookieAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('domainflow_session', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('domainflow_session', 'Bearer');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\CampaignsApi();
$campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 
$phase = phase_example; // String | 

try {
    $result = $api_instance->campaignsPhaseStop($campaignId, $phase);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling CampaignsApi->campaignsPhaseStop: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::CampaignsApi;

# Configure API key authorization: cookieAuth
$WWW::OPenAPIClient::Configuration::api_key->{'domainflow_session'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'domainflow_session'} = "Bearer";

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::CampaignsApi->new();
my $campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; # UUID | 
my $phase = phase_example; # String | 

eval {
    my $result = $api_instance->campaignsPhaseStop(campaignId => $campaignId, phase => $phase);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling CampaignsApi->campaignsPhaseStop: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure API key authorization: cookieAuth
openapi_client.configuration.api_key['domainflow_session'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['domainflow_session'] = 'Bearer'

# Create an instance of the API class
api_instance = openapi_client.CampaignsApi()
campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d # UUID |  (default to null)
phase = phase_example # String |  (default to null)

try:
    # Stop campaign phase
    api_response = api_instance.campaigns_phase_stop(campaignId, phase)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling CampaignsApi->campaignsPhaseStop: %s\n" % e)
extern crate CampaignsApi;

pub fn main() {
    let campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID
    let phase = phase_example; // String

    let mut context = CampaignsApi::Context::default();
    let result = client.campaignsPhaseStop(campaignId, phase, &context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Path parameters
Name Description
campaignId*
UUID (uuid)
Required
phase*
String
Required

Responses


campaignsProgress

Get campaign progress


/campaigns/{campaignId}/progress

Usage and SDK Samples

curl -X GET \
 \
 -H "Accept: application/json" \
 "https://api.domainflow.dev/api/v2/campaigns/{campaignId}/progress"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.CampaignsApi;

import java.io.File;
import java.util.*;

public class CampaignsApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure API key authorization: cookieAuth
        ApiKeyAuth cookieAuth = (ApiKeyAuth) defaultClient.getAuthentication("cookieAuth");
        cookieAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //cookieAuth.setApiKeyPrefix("Token");

        // Create an instance of the API class
        CampaignsApi apiInstance = new CampaignsApi();
        UUID campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 

        try {
            campaigns_progress_200_response result = apiInstance.campaignsProgress(campaignId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling CampaignsApi#campaignsProgress");
            e.printStackTrace();
        }
    }
}
import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final UUID campaignId = new UUID(); // UUID | 

try {
    final result = await api_instance.campaignsProgress(campaignId);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->campaignsProgress: $e\n');
}

import org.openapitools.client.api.CampaignsApi;

public class CampaignsApiExample {
    public static void main(String[] args) {
        CampaignsApi apiInstance = new CampaignsApi();
        UUID campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 

        try {
            campaigns_progress_200_response result = apiInstance.campaignsProgress(campaignId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling CampaignsApi#campaignsProgress");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: cookieAuth)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"domainflow_session"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"domainflow_session"];


// Create an instance of the API class
CampaignsApi *apiInstance = [[CampaignsApi alloc] init];
UUID *campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; //  (default to null)

// Get campaign progress
[apiInstance campaignsProgressWith:campaignId
              completionHandler: ^(campaigns_progress_200_response output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var DomainFlowApi = require('domain_flow_api');
var defaultClient = DomainFlowApi.ApiClient.instance;

// Configure API key authorization: cookieAuth
var cookieAuth = defaultClient.authentications['cookieAuth'];
cookieAuth.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//cookieAuth.apiKeyPrefix['domainflow_session'] = "Token";

// Create an instance of the API class
var api = new DomainFlowApi.CampaignsApi()
var campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // {UUID} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.campaignsProgress(campaignId, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class campaignsProgressExample
    {
        public void main()
        {
            // Configure API key authorization: cookieAuth
            Configuration.Default.ApiKey.Add("domainflow_session", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("domainflow_session", "Bearer");

            // Create an instance of the API class
            var apiInstance = new CampaignsApi();
            var campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d;  // UUID |  (default to null)

            try {
                // Get campaign progress
                campaigns_progress_200_response result = apiInstance.campaignsProgress(campaignId);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling CampaignsApi.campaignsProgress: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure API key authorization: cookieAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('domainflow_session', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('domainflow_session', 'Bearer');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\CampaignsApi();
$campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 

try {
    $result = $api_instance->campaignsProgress($campaignId);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling CampaignsApi->campaignsProgress: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::CampaignsApi;

# Configure API key authorization: cookieAuth
$WWW::OPenAPIClient::Configuration::api_key->{'domainflow_session'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'domainflow_session'} = "Bearer";

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::CampaignsApi->new();
my $campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; # UUID | 

eval {
    my $result = $api_instance->campaignsProgress(campaignId => $campaignId);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling CampaignsApi->campaignsProgress: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure API key authorization: cookieAuth
openapi_client.configuration.api_key['domainflow_session'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['domainflow_session'] = 'Bearer'

# Create an instance of the API class
api_instance = openapi_client.CampaignsApi()
campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d # UUID |  (default to null)

try:
    # Get campaign progress
    api_response = api_instance.campaigns_progress(campaignId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling CampaignsApi->campaignsProgress: %s\n" % e)
extern crate CampaignsApi;

pub fn main() {
    let campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID

    let mut context = CampaignsApi::Context::default();
    let result = client.campaignsProgress(campaignId, &context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Path parameters
Name Description
campaignId*
UUID (uuid)
Required

Responses


campaignsStateDelete

Delete campaign state


/campaigns/{campaignId}/state

Usage and SDK Samples

curl -X DELETE \
 \
 -H "Accept: application/json" \
 "https://api.domainflow.dev/api/v2/campaigns/{campaignId}/state"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.CampaignsApi;

import java.io.File;
import java.util.*;

public class CampaignsApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure API key authorization: cookieAuth
        ApiKeyAuth cookieAuth = (ApiKeyAuth) defaultClient.getAuthentication("cookieAuth");
        cookieAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //cookieAuth.setApiKeyPrefix("Token");

        // Create an instance of the API class
        CampaignsApi apiInstance = new CampaignsApi();
        UUID campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 

        try {
            apiInstance.campaignsStateDelete(campaignId);
        } catch (ApiException e) {
            System.err.println("Exception when calling CampaignsApi#campaignsStateDelete");
            e.printStackTrace();
        }
    }
}
import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final UUID campaignId = new UUID(); // UUID | 

try {
    final result = await api_instance.campaignsStateDelete(campaignId);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->campaignsStateDelete: $e\n');
}

import org.openapitools.client.api.CampaignsApi;

public class CampaignsApiExample {
    public static void main(String[] args) {
        CampaignsApi apiInstance = new CampaignsApi();
        UUID campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 

        try {
            apiInstance.campaignsStateDelete(campaignId);
        } catch (ApiException e) {
            System.err.println("Exception when calling CampaignsApi#campaignsStateDelete");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: cookieAuth)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"domainflow_session"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"domainflow_session"];


// Create an instance of the API class
CampaignsApi *apiInstance = [[CampaignsApi alloc] init];
UUID *campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; //  (default to null)

// Delete campaign state
[apiInstance campaignsStateDeleteWith:campaignId
              completionHandler: ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var DomainFlowApi = require('domain_flow_api');
var defaultClient = DomainFlowApi.ApiClient.instance;

// Configure API key authorization: cookieAuth
var cookieAuth = defaultClient.authentications['cookieAuth'];
cookieAuth.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//cookieAuth.apiKeyPrefix['domainflow_session'] = "Token";

// Create an instance of the API class
var api = new DomainFlowApi.CampaignsApi()
var campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // {UUID} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.campaignsStateDelete(campaignId, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class campaignsStateDeleteExample
    {
        public void main()
        {
            // Configure API key authorization: cookieAuth
            Configuration.Default.ApiKey.Add("domainflow_session", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("domainflow_session", "Bearer");

            // Create an instance of the API class
            var apiInstance = new CampaignsApi();
            var campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d;  // UUID |  (default to null)

            try {
                // Delete campaign state
                apiInstance.campaignsStateDelete(campaignId);
            } catch (Exception e) {
                Debug.Print("Exception when calling CampaignsApi.campaignsStateDelete: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure API key authorization: cookieAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('domainflow_session', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('domainflow_session', 'Bearer');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\CampaignsApi();
$campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 

try {
    $api_instance->campaignsStateDelete($campaignId);
} catch (Exception $e) {
    echo 'Exception when calling CampaignsApi->campaignsStateDelete: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::CampaignsApi;

# Configure API key authorization: cookieAuth
$WWW::OPenAPIClient::Configuration::api_key->{'domainflow_session'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'domainflow_session'} = "Bearer";

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::CampaignsApi->new();
my $campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; # UUID | 

eval {
    $api_instance->campaignsStateDelete(campaignId => $campaignId);
};
if ($@) {
    warn "Exception when calling CampaignsApi->campaignsStateDelete: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure API key authorization: cookieAuth
openapi_client.configuration.api_key['domainflow_session'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['domainflow_session'] = 'Bearer'

# Create an instance of the API class
api_instance = openapi_client.CampaignsApi()
campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d # UUID |  (default to null)

try:
    # Delete campaign state
    api_instance.campaigns_state_delete(campaignId)
except ApiException as e:
    print("Exception when calling CampaignsApi->campaignsStateDelete: %s\n" % e)
extern crate CampaignsApi;

pub fn main() {
    let campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID

    let mut context = CampaignsApi::Context::default();
    let result = client.campaignsStateDelete(campaignId, &context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Path parameters
Name Description
campaignId*
UUID (uuid)
Required

Responses


campaignsStateGet

Get campaign state


/campaigns/{campaignId}/state

Usage and SDK Samples

curl -X GET \
 \
 -H "Accept: application/json" \
 "https://api.domainflow.dev/api/v2/campaigns/{campaignId}/state"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.CampaignsApi;

import java.io.File;
import java.util.*;

public class CampaignsApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure API key authorization: cookieAuth
        ApiKeyAuth cookieAuth = (ApiKeyAuth) defaultClient.getAuthentication("cookieAuth");
        cookieAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //cookieAuth.setApiKeyPrefix("Token");

        // Create an instance of the API class
        CampaignsApi apiInstance = new CampaignsApi();
        UUID campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 

        try {
            campaigns_state_get_200_response result = apiInstance.campaignsStateGet(campaignId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling CampaignsApi#campaignsStateGet");
            e.printStackTrace();
        }
    }
}
import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final UUID campaignId = new UUID(); // UUID | 

try {
    final result = await api_instance.campaignsStateGet(campaignId);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->campaignsStateGet: $e\n');
}

import org.openapitools.client.api.CampaignsApi;

public class CampaignsApiExample {
    public static void main(String[] args) {
        CampaignsApi apiInstance = new CampaignsApi();
        UUID campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 

        try {
            campaigns_state_get_200_response result = apiInstance.campaignsStateGet(campaignId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling CampaignsApi#campaignsStateGet");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: cookieAuth)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"domainflow_session"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"domainflow_session"];


// Create an instance of the API class
CampaignsApi *apiInstance = [[CampaignsApi alloc] init];
UUID *campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; //  (default to null)

// Get campaign state
[apiInstance campaignsStateGetWith:campaignId
              completionHandler: ^(campaigns_state_get_200_response output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var DomainFlowApi = require('domain_flow_api');
var defaultClient = DomainFlowApi.ApiClient.instance;

// Configure API key authorization: cookieAuth
var cookieAuth = defaultClient.authentications['cookieAuth'];
cookieAuth.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//cookieAuth.apiKeyPrefix['domainflow_session'] = "Token";

// Create an instance of the API class
var api = new DomainFlowApi.CampaignsApi()
var campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // {UUID} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.campaignsStateGet(campaignId, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class campaignsStateGetExample
    {
        public void main()
        {
            // Configure API key authorization: cookieAuth
            Configuration.Default.ApiKey.Add("domainflow_session", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("domainflow_session", "Bearer");

            // Create an instance of the API class
            var apiInstance = new CampaignsApi();
            var campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d;  // UUID |  (default to null)

            try {
                // Get campaign state
                campaigns_state_get_200_response result = apiInstance.campaignsStateGet(campaignId);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling CampaignsApi.campaignsStateGet: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure API key authorization: cookieAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('domainflow_session', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('domainflow_session', 'Bearer');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\CampaignsApi();
$campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 

try {
    $result = $api_instance->campaignsStateGet($campaignId);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling CampaignsApi->campaignsStateGet: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::CampaignsApi;

# Configure API key authorization: cookieAuth
$WWW::OPenAPIClient::Configuration::api_key->{'domainflow_session'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'domainflow_session'} = "Bearer";

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::CampaignsApi->new();
my $campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; # UUID | 

eval {
    my $result = $api_instance->campaignsStateGet(campaignId => $campaignId);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling CampaignsApi->campaignsStateGet: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure API key authorization: cookieAuth
openapi_client.configuration.api_key['domainflow_session'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['domainflow_session'] = 'Bearer'

# Create an instance of the API class
api_instance = openapi_client.CampaignsApi()
campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d # UUID |  (default to null)

try:
    # Get campaign state
    api_response = api_instance.campaigns_state_get(campaignId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling CampaignsApi->campaignsStateGet: %s\n" % e)
extern crate CampaignsApi;

pub fn main() {
    let campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID

    let mut context = CampaignsApi::Context::default();
    let result = client.campaignsStateGet(campaignId, &context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Path parameters
Name Description
campaignId*
UUID (uuid)
Required

Responses


campaignsStatePut

Update campaign state


/campaigns/{campaignId}/state

Usage and SDK Samples

curl -X PUT \
 \
 -H "Accept: application/json" \
 -H "Content-Type: application/json" \
 "https://api.domainflow.dev/api/v2/campaigns/{campaignId}/state" \
 -d '{
  "mode" : "full_sequence",
  "configuration" : {
    "key" : ""
  },
  "currentState" : "draft",
  "version" : 0
}'
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.CampaignsApi;

import java.io.File;
import java.util.*;

public class CampaignsApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure API key authorization: cookieAuth
        ApiKeyAuth cookieAuth = (ApiKeyAuth) defaultClient.getAuthentication("cookieAuth");
        cookieAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //cookieAuth.setApiKeyPrefix("Token");

        // Create an instance of the API class
        CampaignsApi apiInstance = new CampaignsApi();
        UUID campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 
        CampaignStateUpdate campaignStateUpdate = ; // CampaignStateUpdate | 

        try {
            campaigns_state_get_200_response result = apiInstance.campaignsStatePut(campaignId, campaignStateUpdate);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling CampaignsApi#campaignsStatePut");
            e.printStackTrace();
        }
    }
}
import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final UUID campaignId = new UUID(); // UUID | 
final CampaignStateUpdate campaignStateUpdate = new CampaignStateUpdate(); // CampaignStateUpdate | 

try {
    final result = await api_instance.campaignsStatePut(campaignId, campaignStateUpdate);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->campaignsStatePut: $e\n');
}

import org.openapitools.client.api.CampaignsApi;

public class CampaignsApiExample {
    public static void main(String[] args) {
        CampaignsApi apiInstance = new CampaignsApi();
        UUID campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 
        CampaignStateUpdate campaignStateUpdate = ; // CampaignStateUpdate | 

        try {
            campaigns_state_get_200_response result = apiInstance.campaignsStatePut(campaignId, campaignStateUpdate);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling CampaignsApi#campaignsStatePut");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: cookieAuth)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"domainflow_session"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"domainflow_session"];


// Create an instance of the API class
CampaignsApi *apiInstance = [[CampaignsApi alloc] init];
UUID *campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; //  (default to null)
CampaignStateUpdate *campaignStateUpdate = ; // 

// Update campaign state
[apiInstance campaignsStatePutWith:campaignId
    campaignStateUpdate:campaignStateUpdate
              completionHandler: ^(campaigns_state_get_200_response output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var DomainFlowApi = require('domain_flow_api');
var defaultClient = DomainFlowApi.ApiClient.instance;

// Configure API key authorization: cookieAuth
var cookieAuth = defaultClient.authentications['cookieAuth'];
cookieAuth.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//cookieAuth.apiKeyPrefix['domainflow_session'] = "Token";

// Create an instance of the API class
var api = new DomainFlowApi.CampaignsApi()
var campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // {UUID} 
var campaignStateUpdate = ; // {CampaignStateUpdate} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.campaignsStatePut(campaignId, campaignStateUpdate, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class campaignsStatePutExample
    {
        public void main()
        {
            // Configure API key authorization: cookieAuth
            Configuration.Default.ApiKey.Add("domainflow_session", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("domainflow_session", "Bearer");

            // Create an instance of the API class
            var apiInstance = new CampaignsApi();
            var campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d;  // UUID |  (default to null)
            var campaignStateUpdate = new CampaignStateUpdate(); // CampaignStateUpdate | 

            try {
                // Update campaign state
                campaigns_state_get_200_response result = apiInstance.campaignsStatePut(campaignId, campaignStateUpdate);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling CampaignsApi.campaignsStatePut: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure API key authorization: cookieAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('domainflow_session', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('domainflow_session', 'Bearer');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\CampaignsApi();
$campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 
$campaignStateUpdate = ; // CampaignStateUpdate | 

try {
    $result = $api_instance->campaignsStatePut($campaignId, $campaignStateUpdate);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling CampaignsApi->campaignsStatePut: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::CampaignsApi;

# Configure API key authorization: cookieAuth
$WWW::OPenAPIClient::Configuration::api_key->{'domainflow_session'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'domainflow_session'} = "Bearer";

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::CampaignsApi->new();
my $campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; # UUID | 
my $campaignStateUpdate = WWW::OPenAPIClient::Object::CampaignStateUpdate->new(); # CampaignStateUpdate | 

eval {
    my $result = $api_instance->campaignsStatePut(campaignId => $campaignId, campaignStateUpdate => $campaignStateUpdate);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling CampaignsApi->campaignsStatePut: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure API key authorization: cookieAuth
openapi_client.configuration.api_key['domainflow_session'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['domainflow_session'] = 'Bearer'

# Create an instance of the API class
api_instance = openapi_client.CampaignsApi()
campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d # UUID |  (default to null)
campaignStateUpdate =  # CampaignStateUpdate | 

try:
    # Update campaign state
    api_response = api_instance.campaigns_state_put(campaignId, campaignStateUpdate)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling CampaignsApi->campaignsStatePut: %s\n" % e)
extern crate CampaignsApi;

pub fn main() {
    let campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID
    let campaignStateUpdate = ; // CampaignStateUpdate

    let mut context = CampaignsApi::Context::default();
    let result = client.campaignsStatePut(campaignId, campaignStateUpdate, &context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Path parameters
Name Description
campaignId*
UUID (uuid)
Required
Body parameters
Name Description
campaignStateUpdate *

Responses


campaignsUpdate

Update campaign


/campaigns/{campaignId}

Usage and SDK Samples

curl -X PUT \
 \
 -H "Accept: application/json" \
 -H "Content-Type: application/json" \
 "https://api.domainflow.dev/api/v2/campaigns/{campaignId}" \
 -d '{
  "configuration" : "{}",
  "name" : "name",
  "description" : "description"
}'
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.CampaignsApi;

import java.io.File;
import java.util.*;

public class CampaignsApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure API key authorization: cookieAuth
        ApiKeyAuth cookieAuth = (ApiKeyAuth) defaultClient.getAuthentication("cookieAuth");
        cookieAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //cookieAuth.setApiKeyPrefix("Token");

        // Create an instance of the API class
        CampaignsApi apiInstance = new CampaignsApi();
        UUID campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 
        UpdateCampaignRequest updateCampaignRequest = ; // UpdateCampaignRequest | 

        try {
            campaigns_create_201_response result = apiInstance.campaignsUpdate(campaignId, updateCampaignRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling CampaignsApi#campaignsUpdate");
            e.printStackTrace();
        }
    }
}
import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final UUID campaignId = new UUID(); // UUID | 
final UpdateCampaignRequest updateCampaignRequest = new UpdateCampaignRequest(); // UpdateCampaignRequest | 

try {
    final result = await api_instance.campaignsUpdate(campaignId, updateCampaignRequest);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->campaignsUpdate: $e\n');
}

import org.openapitools.client.api.CampaignsApi;

public class CampaignsApiExample {
    public static void main(String[] args) {
        CampaignsApi apiInstance = new CampaignsApi();
        UUID campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 
        UpdateCampaignRequest updateCampaignRequest = ; // UpdateCampaignRequest | 

        try {
            campaigns_create_201_response result = apiInstance.campaignsUpdate(campaignId, updateCampaignRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling CampaignsApi#campaignsUpdate");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: cookieAuth)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"domainflow_session"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"domainflow_session"];


// Create an instance of the API class
CampaignsApi *apiInstance = [[CampaignsApi alloc] init];
UUID *campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; //  (default to null)
UpdateCampaignRequest *updateCampaignRequest = ; // 

// Update campaign
[apiInstance campaignsUpdateWith:campaignId
    updateCampaignRequest:updateCampaignRequest
              completionHandler: ^(campaigns_create_201_response output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var DomainFlowApi = require('domain_flow_api');
var defaultClient = DomainFlowApi.ApiClient.instance;

// Configure API key authorization: cookieAuth
var cookieAuth = defaultClient.authentications['cookieAuth'];
cookieAuth.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//cookieAuth.apiKeyPrefix['domainflow_session'] = "Token";

// Create an instance of the API class
var api = new DomainFlowApi.CampaignsApi()
var campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // {UUID} 
var updateCampaignRequest = ; // {UpdateCampaignRequest} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.campaignsUpdate(campaignId, updateCampaignRequest, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class campaignsUpdateExample
    {
        public void main()
        {
            // Configure API key authorization: cookieAuth
            Configuration.Default.ApiKey.Add("domainflow_session", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("domainflow_session", "Bearer");

            // Create an instance of the API class
            var apiInstance = new CampaignsApi();
            var campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d;  // UUID |  (default to null)
            var updateCampaignRequest = new UpdateCampaignRequest(); // UpdateCampaignRequest | 

            try {
                // Update campaign
                campaigns_create_201_response result = apiInstance.campaignsUpdate(campaignId, updateCampaignRequest);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling CampaignsApi.campaignsUpdate: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure API key authorization: cookieAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('domainflow_session', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('domainflow_session', 'Bearer');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\CampaignsApi();
$campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 
$updateCampaignRequest = ; // UpdateCampaignRequest | 

try {
    $result = $api_instance->campaignsUpdate($campaignId, $updateCampaignRequest);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling CampaignsApi->campaignsUpdate: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::CampaignsApi;

# Configure API key authorization: cookieAuth
$WWW::OPenAPIClient::Configuration::api_key->{'domainflow_session'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'domainflow_session'} = "Bearer";

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::CampaignsApi->new();
my $campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; # UUID | 
my $updateCampaignRequest = WWW::OPenAPIClient::Object::UpdateCampaignRequest->new(); # UpdateCampaignRequest | 

eval {
    my $result = $api_instance->campaignsUpdate(campaignId => $campaignId, updateCampaignRequest => $updateCampaignRequest);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling CampaignsApi->campaignsUpdate: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure API key authorization: cookieAuth
openapi_client.configuration.api_key['domainflow_session'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['domainflow_session'] = 'Bearer'

# Create an instance of the API class
api_instance = openapi_client.CampaignsApi()
campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d # UUID |  (default to null)
updateCampaignRequest =  # UpdateCampaignRequest | 

try:
    # Update campaign
    api_response = api_instance.campaigns_update(campaignId, updateCampaignRequest)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling CampaignsApi->campaignsUpdate: %s\n" % e)
extern crate CampaignsApi;

pub fn main() {
    let campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID
    let updateCampaignRequest = ; // UpdateCampaignRequest

    let mut context = CampaignsApi::Context::default();
    let result = client.campaignsUpdate(campaignId, updateCampaignRequest, &context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Path parameters
Name Description
campaignId*
UUID (uuid)
Required
Body parameters
Name Description
updateCampaignRequest *

Responses


cancelBulkOperation

Cancel bulk operation


/campaigns/bulk/operations/{operationId}/cancel

Usage and SDK Samples

curl -X POST \
 \
 -H "Accept: application/json" \
 "https://api.domainflow.dev/api/v2/campaigns/bulk/operations/{operationId}/cancel"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.CampaignsApi;

import java.io.File;
import java.util.*;

public class CampaignsApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure API key authorization: cookieAuth
        ApiKeyAuth cookieAuth = (ApiKeyAuth) defaultClient.getAuthentication("cookieAuth");
        cookieAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //cookieAuth.setApiKeyPrefix("Token");

        // Create an instance of the API class
        CampaignsApi apiInstance = new CampaignsApi();
        UUID operationId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | Bulk operation ID to cancel

        try {
            cancelBulkOperation_200_response result = apiInstance.cancelBulkOperation(operationId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling CampaignsApi#cancelBulkOperation");
            e.printStackTrace();
        }
    }
}
import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final UUID operationId = new UUID(); // UUID | Bulk operation ID to cancel

try {
    final result = await api_instance.cancelBulkOperation(operationId);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->cancelBulkOperation: $e\n');
}

import org.openapitools.client.api.CampaignsApi;

public class CampaignsApiExample {
    public static void main(String[] args) {
        CampaignsApi apiInstance = new CampaignsApi();
        UUID operationId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | Bulk operation ID to cancel

        try {
            cancelBulkOperation_200_response result = apiInstance.cancelBulkOperation(operationId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling CampaignsApi#cancelBulkOperation");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: cookieAuth)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"domainflow_session"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"domainflow_session"];


// Create an instance of the API class
CampaignsApi *apiInstance = [[CampaignsApi alloc] init];
UUID *operationId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // Bulk operation ID to cancel (default to null)

// Cancel bulk operation
[apiInstance cancelBulkOperationWith:operationId
              completionHandler: ^(cancelBulkOperation_200_response output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var DomainFlowApi = require('domain_flow_api');
var defaultClient = DomainFlowApi.ApiClient.instance;

// Configure API key authorization: cookieAuth
var cookieAuth = defaultClient.authentications['cookieAuth'];
cookieAuth.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//cookieAuth.apiKeyPrefix['domainflow_session'] = "Token";

// Create an instance of the API class
var api = new DomainFlowApi.CampaignsApi()
var operationId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // {UUID} Bulk operation ID to cancel

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.cancelBulkOperation(operationId, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class cancelBulkOperationExample
    {
        public void main()
        {
            // Configure API key authorization: cookieAuth
            Configuration.Default.ApiKey.Add("domainflow_session", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("domainflow_session", "Bearer");

            // Create an instance of the API class
            var apiInstance = new CampaignsApi();
            var operationId = 38400000-8cf0-11bd-b23e-10b96e4ef00d;  // UUID | Bulk operation ID to cancel (default to null)

            try {
                // Cancel bulk operation
                cancelBulkOperation_200_response result = apiInstance.cancelBulkOperation(operationId);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling CampaignsApi.cancelBulkOperation: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure API key authorization: cookieAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('domainflow_session', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('domainflow_session', 'Bearer');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\CampaignsApi();
$operationId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | Bulk operation ID to cancel

try {
    $result = $api_instance->cancelBulkOperation($operationId);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling CampaignsApi->cancelBulkOperation: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::CampaignsApi;

# Configure API key authorization: cookieAuth
$WWW::OPenAPIClient::Configuration::api_key->{'domainflow_session'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'domainflow_session'} = "Bearer";

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::CampaignsApi->new();
my $operationId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; # UUID | Bulk operation ID to cancel

eval {
    my $result = $api_instance->cancelBulkOperation(operationId => $operationId);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling CampaignsApi->cancelBulkOperation: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure API key authorization: cookieAuth
openapi_client.configuration.api_key['domainflow_session'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['domainflow_session'] = 'Bearer'

# Create an instance of the API class
api_instance = openapi_client.CampaignsApi()
operationId = 38400000-8cf0-11bd-b23e-10b96e4ef00d # UUID | Bulk operation ID to cancel (default to null)

try:
    # Cancel bulk operation
    api_response = api_instance.cancel_bulk_operation(operationId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling CampaignsApi->cancelBulkOperation: %s\n" % e)
extern crate CampaignsApi;

pub fn main() {
    let operationId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID

    let mut context = CampaignsApi::Context::default();
    let result = client.cancelBulkOperation(operationId, &context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Path parameters
Name Description
operationId*
UUID (uuid)
Bulk operation ID to cancel
Required

Responses

Name Type Format Description
Retry-After Integer Seconds to wait before retrying


getBulkOperationStatus

Get bulk operation status


/campaigns/bulk/operations/{operationId}/status

Usage and SDK Samples

curl -X GET \
 \
 -H "Accept: application/json" \
 "https://api.domainflow.dev/api/v2/campaigns/bulk/operations/{operationId}/status"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.CampaignsApi;

import java.io.File;
import java.util.*;

public class CampaignsApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure API key authorization: cookieAuth
        ApiKeyAuth cookieAuth = (ApiKeyAuth) defaultClient.getAuthentication("cookieAuth");
        cookieAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //cookieAuth.setApiKeyPrefix("Token");

        // Create an instance of the API class
        CampaignsApi apiInstance = new CampaignsApi();
        UUID operationId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | Bulk operation ID

        try {
            getBulkOperationStatus_200_response result = apiInstance.getBulkOperationStatus(operationId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling CampaignsApi#getBulkOperationStatus");
            e.printStackTrace();
        }
    }
}
import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final UUID operationId = new UUID(); // UUID | Bulk operation ID

try {
    final result = await api_instance.getBulkOperationStatus(operationId);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->getBulkOperationStatus: $e\n');
}

import org.openapitools.client.api.CampaignsApi;

public class CampaignsApiExample {
    public static void main(String[] args) {
        CampaignsApi apiInstance = new CampaignsApi();
        UUID operationId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | Bulk operation ID

        try {
            getBulkOperationStatus_200_response result = apiInstance.getBulkOperationStatus(operationId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling CampaignsApi#getBulkOperationStatus");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: cookieAuth)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"domainflow_session"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"domainflow_session"];


// Create an instance of the API class
CampaignsApi *apiInstance = [[CampaignsApi alloc] init];
UUID *operationId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // Bulk operation ID (default to null)

// Get bulk operation status
[apiInstance getBulkOperationStatusWith:operationId
              completionHandler: ^(getBulkOperationStatus_200_response output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var DomainFlowApi = require('domain_flow_api');
var defaultClient = DomainFlowApi.ApiClient.instance;

// Configure API key authorization: cookieAuth
var cookieAuth = defaultClient.authentications['cookieAuth'];
cookieAuth.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//cookieAuth.apiKeyPrefix['domainflow_session'] = "Token";

// Create an instance of the API class
var api = new DomainFlowApi.CampaignsApi()
var operationId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // {UUID} Bulk operation ID

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.getBulkOperationStatus(operationId, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class getBulkOperationStatusExample
    {
        public void main()
        {
            // Configure API key authorization: cookieAuth
            Configuration.Default.ApiKey.Add("domainflow_session", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("domainflow_session", "Bearer");

            // Create an instance of the API class
            var apiInstance = new CampaignsApi();
            var operationId = 38400000-8cf0-11bd-b23e-10b96e4ef00d;  // UUID | Bulk operation ID (default to null)

            try {
                // Get bulk operation status
                getBulkOperationStatus_200_response result = apiInstance.getBulkOperationStatus(operationId);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling CampaignsApi.getBulkOperationStatus: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure API key authorization: cookieAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('domainflow_session', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('domainflow_session', 'Bearer');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\CampaignsApi();
$operationId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | Bulk operation ID

try {
    $result = $api_instance->getBulkOperationStatus($operationId);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling CampaignsApi->getBulkOperationStatus: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::CampaignsApi;

# Configure API key authorization: cookieAuth
$WWW::OPenAPIClient::Configuration::api_key->{'domainflow_session'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'domainflow_session'} = "Bearer";

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::CampaignsApi->new();
my $operationId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; # UUID | Bulk operation ID

eval {
    my $result = $api_instance->getBulkOperationStatus(operationId => $operationId);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling CampaignsApi->getBulkOperationStatus: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure API key authorization: cookieAuth
openapi_client.configuration.api_key['domainflow_session'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['domainflow_session'] = 'Bearer'

# Create an instance of the API class
api_instance = openapi_client.CampaignsApi()
operationId = 38400000-8cf0-11bd-b23e-10b96e4ef00d # UUID | Bulk operation ID (default to null)

try:
    # Get bulk operation status
    api_response = api_instance.get_bulk_operation_status(operationId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling CampaignsApi->getBulkOperationStatus: %s\n" % e)
extern crate CampaignsApi;

pub fn main() {
    let operationId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID

    let mut context = CampaignsApi::Context::default();
    let result = client.getBulkOperationStatus(operationId, &context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Path parameters
Name Description
operationId*
UUID (uuid)
Bulk operation ID
Required

Responses

Name Type Format Description
Retry-After Integer Seconds to wait before retrying


getBulkResourceStatus

Get bulk resource allocation status


/campaigns/bulk/resources/status/{allocationId}

Usage and SDK Samples

curl -X GET \
 \
 -H "Accept: application/json" \
 "https://api.domainflow.dev/api/v2/campaigns/bulk/resources/status/{allocationId}"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.CampaignsApi;

import java.io.File;
import java.util.*;

public class CampaignsApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure API key authorization: cookieAuth
        ApiKeyAuth cookieAuth = (ApiKeyAuth) defaultClient.getAuthentication("cookieAuth");
        cookieAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //cookieAuth.setApiKeyPrefix("Token");

        // Create an instance of the API class
        CampaignsApi apiInstance = new CampaignsApi();
        UUID allocationId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | Resource allocation ID

        try {
            getBulkResourceStatus_200_response result = apiInstance.getBulkResourceStatus(allocationId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling CampaignsApi#getBulkResourceStatus");
            e.printStackTrace();
        }
    }
}
import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final UUID allocationId = new UUID(); // UUID | Resource allocation ID

try {
    final result = await api_instance.getBulkResourceStatus(allocationId);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->getBulkResourceStatus: $e\n');
}

import org.openapitools.client.api.CampaignsApi;

public class CampaignsApiExample {
    public static void main(String[] args) {
        CampaignsApi apiInstance = new CampaignsApi();
        UUID allocationId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | Resource allocation ID

        try {
            getBulkResourceStatus_200_response result = apiInstance.getBulkResourceStatus(allocationId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling CampaignsApi#getBulkResourceStatus");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: cookieAuth)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"domainflow_session"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"domainflow_session"];


// Create an instance of the API class
CampaignsApi *apiInstance = [[CampaignsApi alloc] init];
UUID *allocationId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // Resource allocation ID (default to null)

// Get bulk resource allocation status
[apiInstance getBulkResourceStatusWith:allocationId
              completionHandler: ^(getBulkResourceStatus_200_response output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var DomainFlowApi = require('domain_flow_api');
var defaultClient = DomainFlowApi.ApiClient.instance;

// Configure API key authorization: cookieAuth
var cookieAuth = defaultClient.authentications['cookieAuth'];
cookieAuth.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//cookieAuth.apiKeyPrefix['domainflow_session'] = "Token";

// Create an instance of the API class
var api = new DomainFlowApi.CampaignsApi()
var allocationId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // {UUID} Resource allocation ID

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.getBulkResourceStatus(allocationId, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class getBulkResourceStatusExample
    {
        public void main()
        {
            // Configure API key authorization: cookieAuth
            Configuration.Default.ApiKey.Add("domainflow_session", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("domainflow_session", "Bearer");

            // Create an instance of the API class
            var apiInstance = new CampaignsApi();
            var allocationId = 38400000-8cf0-11bd-b23e-10b96e4ef00d;  // UUID | Resource allocation ID (default to null)

            try {
                // Get bulk resource allocation status
                getBulkResourceStatus_200_response result = apiInstance.getBulkResourceStatus(allocationId);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling CampaignsApi.getBulkResourceStatus: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure API key authorization: cookieAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('domainflow_session', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('domainflow_session', 'Bearer');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\CampaignsApi();
$allocationId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | Resource allocation ID

try {
    $result = $api_instance->getBulkResourceStatus($allocationId);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling CampaignsApi->getBulkResourceStatus: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::CampaignsApi;

# Configure API key authorization: cookieAuth
$WWW::OPenAPIClient::Configuration::api_key->{'domainflow_session'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'domainflow_session'} = "Bearer";

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::CampaignsApi->new();
my $allocationId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; # UUID | Resource allocation ID

eval {
    my $result = $api_instance->getBulkResourceStatus(allocationId => $allocationId);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling CampaignsApi->getBulkResourceStatus: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure API key authorization: cookieAuth
openapi_client.configuration.api_key['domainflow_session'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['domainflow_session'] = 'Bearer'

# Create an instance of the API class
api_instance = openapi_client.CampaignsApi()
allocationId = 38400000-8cf0-11bd-b23e-10b96e4ef00d # UUID | Resource allocation ID (default to null)

try:
    # Get bulk resource allocation status
    api_response = api_instance.get_bulk_resource_status(allocationId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling CampaignsApi->getBulkResourceStatus: %s\n" % e)
extern crate CampaignsApi;

pub fn main() {
    let allocationId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID

    let mut context = CampaignsApi::Context::default();
    let result = client.getBulkResourceStatus(allocationId, &context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Path parameters
Name Description
allocationId*
UUID (uuid)
Resource allocation ID
Required

Responses

Name Type Format Description
Retry-After Integer Seconds to wait before retrying


Database

dbBulkQuery

Execute bulk database queries


/database/query

Usage and SDK Samples

curl -X POST \
 \
 -H "Accept: application/json" \
 -H "Content-Type: application/json" \
 "https://api.domainflow.dev/api/v2/database/query" \
 -d '{
  "limit" : 0,
  "queries" : [ {
    "id" : "id",
    "sql" : "sql"
  }, {
    "id" : "id",
    "sql" : "sql"
  } ],
  "timeout" : 6
}'
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.DatabaseApi;

import java.io.File;
import java.util.*;

public class DatabaseApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure API key authorization: cookieAuth
        ApiKeyAuth cookieAuth = (ApiKeyAuth) defaultClient.getAuthentication("cookieAuth");
        cookieAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //cookieAuth.setApiKeyPrefix("Token");

        // Create an instance of the API class
        DatabaseApi apiInstance = new DatabaseApi();
        BulkDatabaseQueryRequest bulkDatabaseQueryRequest = ; // BulkDatabaseQueryRequest | 
        String xRequestedWith = xRequestedWith_example; // String | CSRF/XHR sentinel header. Must be exactly "XMLHttpRequest" for browser-initiated unsafe requests.

        try {
            db_bulk_query_200_response result = apiInstance.dbBulkQuery(bulkDatabaseQueryRequest, xRequestedWith);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DatabaseApi#dbBulkQuery");
            e.printStackTrace();
        }
    }
}
import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final BulkDatabaseQueryRequest bulkDatabaseQueryRequest = new BulkDatabaseQueryRequest(); // BulkDatabaseQueryRequest | 
final String xRequestedWith = new String(); // String | CSRF/XHR sentinel header. Must be exactly "XMLHttpRequest" for browser-initiated unsafe requests.

try {
    final result = await api_instance.dbBulkQuery(bulkDatabaseQueryRequest, xRequestedWith);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->dbBulkQuery: $e\n');
}

import org.openapitools.client.api.DatabaseApi;

public class DatabaseApiExample {
    public static void main(String[] args) {
        DatabaseApi apiInstance = new DatabaseApi();
        BulkDatabaseQueryRequest bulkDatabaseQueryRequest = ; // BulkDatabaseQueryRequest | 
        String xRequestedWith = xRequestedWith_example; // String | CSRF/XHR sentinel header. Must be exactly "XMLHttpRequest" for browser-initiated unsafe requests.

        try {
            db_bulk_query_200_response result = apiInstance.dbBulkQuery(bulkDatabaseQueryRequest, xRequestedWith);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DatabaseApi#dbBulkQuery");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: cookieAuth)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"domainflow_session"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"domainflow_session"];


// Create an instance of the API class
DatabaseApi *apiInstance = [[DatabaseApi alloc] init];
BulkDatabaseQueryRequest *bulkDatabaseQueryRequest = ; // 
String *xRequestedWith = xRequestedWith_example; // CSRF/XHR sentinel header. Must be exactly "XMLHttpRequest" for browser-initiated unsafe requests. (optional) (default to null)

// Execute bulk database queries
[apiInstance dbBulkQueryWith:bulkDatabaseQueryRequest
    xRequestedWith:xRequestedWith
              completionHandler: ^(db_bulk_query_200_response output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var DomainFlowApi = require('domain_flow_api');
var defaultClient = DomainFlowApi.ApiClient.instance;

// Configure API key authorization: cookieAuth
var cookieAuth = defaultClient.authentications['cookieAuth'];
cookieAuth.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//cookieAuth.apiKeyPrefix['domainflow_session'] = "Token";

// Create an instance of the API class
var api = new DomainFlowApi.DatabaseApi()
var bulkDatabaseQueryRequest = ; // {BulkDatabaseQueryRequest} 
var opts = {
  'xRequestedWith': xRequestedWith_example // {String} CSRF/XHR sentinel header. Must be exactly "XMLHttpRequest" for browser-initiated unsafe requests.
};

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.dbBulkQuery(bulkDatabaseQueryRequest, opts, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class dbBulkQueryExample
    {
        public void main()
        {
            // Configure API key authorization: cookieAuth
            Configuration.Default.ApiKey.Add("domainflow_session", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("domainflow_session", "Bearer");

            // Create an instance of the API class
            var apiInstance = new DatabaseApi();
            var bulkDatabaseQueryRequest = new BulkDatabaseQueryRequest(); // BulkDatabaseQueryRequest | 
            var xRequestedWith = xRequestedWith_example;  // String | CSRF/XHR sentinel header. Must be exactly "XMLHttpRequest" for browser-initiated unsafe requests. (optional)  (default to null)

            try {
                // Execute bulk database queries
                db_bulk_query_200_response result = apiInstance.dbBulkQuery(bulkDatabaseQueryRequest, xRequestedWith);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling DatabaseApi.dbBulkQuery: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure API key authorization: cookieAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('domainflow_session', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('domainflow_session', 'Bearer');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\DatabaseApi();
$bulkDatabaseQueryRequest = ; // BulkDatabaseQueryRequest | 
$xRequestedWith = xRequestedWith_example; // String | CSRF/XHR sentinel header. Must be exactly "XMLHttpRequest" for browser-initiated unsafe requests.

try {
    $result = $api_instance->dbBulkQuery($bulkDatabaseQueryRequest, $xRequestedWith);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling DatabaseApi->dbBulkQuery: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::DatabaseApi;

# Configure API key authorization: cookieAuth
$WWW::OPenAPIClient::Configuration::api_key->{'domainflow_session'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'domainflow_session'} = "Bearer";

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::DatabaseApi->new();
my $bulkDatabaseQueryRequest = WWW::OPenAPIClient::Object::BulkDatabaseQueryRequest->new(); # BulkDatabaseQueryRequest | 
my $xRequestedWith = xRequestedWith_example; # String | CSRF/XHR sentinel header. Must be exactly "XMLHttpRequest" for browser-initiated unsafe requests.

eval {
    my $result = $api_instance->dbBulkQuery(bulkDatabaseQueryRequest => $bulkDatabaseQueryRequest, xRequestedWith => $xRequestedWith);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling DatabaseApi->dbBulkQuery: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure API key authorization: cookieAuth
openapi_client.configuration.api_key['domainflow_session'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['domainflow_session'] = 'Bearer'

# Create an instance of the API class
api_instance = openapi_client.DatabaseApi()
bulkDatabaseQueryRequest =  # BulkDatabaseQueryRequest | 
xRequestedWith = xRequestedWith_example # String | CSRF/XHR sentinel header. Must be exactly "XMLHttpRequest" for browser-initiated unsafe requests. (optional) (default to null)

try:
    # Execute bulk database queries
    api_response = api_instance.db_bulk_query(bulkDatabaseQueryRequest, xRequestedWith=xRequestedWith)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DatabaseApi->dbBulkQuery: %s\n" % e)
extern crate DatabaseApi;

pub fn main() {
    let bulkDatabaseQueryRequest = ; // BulkDatabaseQueryRequest
    let xRequestedWith = xRequestedWith_example; // String

    let mut context = DatabaseApi::Context::default();
    let result = client.dbBulkQuery(bulkDatabaseQueryRequest, xRequestedWith, &context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Header parameters
Name Description
X-Requested-With
String
CSRF/XHR sentinel header. Must be exactly "XMLHttpRequest" for browser-initiated unsafe requests.
Body parameters
Name Description
bulkDatabaseQueryRequest *

Responses

Name Type Format Description
Retry-After Integer Seconds to wait before retrying


dbBulkStats

Get bulk database statistics

Retrieve comprehensive database statistics including schema and table-level details


/database/stats

Usage and SDK Samples

curl -X POST \
 \
 -H "Accept: application/json" \
 -H "Content-Type: application/json" \
 "https://api.domainflow.dev/api/v2/database/stats" \
 -d '{
  "tables" : [ "tables", "tables" ],
  "schemas" : [ "schemas", "schemas" ],
  "includeIndexes" : true,
  "includeSize" : true
}'
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.DatabaseApi;

import java.io.File;
import java.util.*;

public class DatabaseApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure API key authorization: cookieAuth
        ApiKeyAuth cookieAuth = (ApiKeyAuth) defaultClient.getAuthentication("cookieAuth");
        cookieAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //cookieAuth.setApiKeyPrefix("Token");

        // Create an instance of the API class
        DatabaseApi apiInstance = new DatabaseApi();
        BulkDatabaseStatsRequest bulkDatabaseStatsRequest = ; // BulkDatabaseStatsRequest | 
        String xRequestedWith = xRequestedWith_example; // String | CSRF/XHR sentinel header. Must be exactly "XMLHttpRequest" for browser-initiated unsafe requests.

        try {
            db_bulk_stats_200_response result = apiInstance.dbBulkStats(bulkDatabaseStatsRequest, xRequestedWith);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DatabaseApi#dbBulkStats");
            e.printStackTrace();
        }
    }
}
import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final BulkDatabaseStatsRequest bulkDatabaseStatsRequest = new BulkDatabaseStatsRequest(); // BulkDatabaseStatsRequest | 
final String xRequestedWith = new String(); // String | CSRF/XHR sentinel header. Must be exactly "XMLHttpRequest" for browser-initiated unsafe requests.

try {
    final result = await api_instance.dbBulkStats(bulkDatabaseStatsRequest, xRequestedWith);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->dbBulkStats: $e\n');
}

import org.openapitools.client.api.DatabaseApi;

public class DatabaseApiExample {
    public static void main(String[] args) {
        DatabaseApi apiInstance = new DatabaseApi();
        BulkDatabaseStatsRequest bulkDatabaseStatsRequest = ; // BulkDatabaseStatsRequest | 
        String xRequestedWith = xRequestedWith_example; // String | CSRF/XHR sentinel header. Must be exactly "XMLHttpRequest" for browser-initiated unsafe requests.

        try {
            db_bulk_stats_200_response result = apiInstance.dbBulkStats(bulkDatabaseStatsRequest, xRequestedWith);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DatabaseApi#dbBulkStats");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: cookieAuth)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"domainflow_session"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"domainflow_session"];


// Create an instance of the API class
DatabaseApi *apiInstance = [[DatabaseApi alloc] init];
BulkDatabaseStatsRequest *bulkDatabaseStatsRequest = ; // 
String *xRequestedWith = xRequestedWith_example; // CSRF/XHR sentinel header. Must be exactly "XMLHttpRequest" for browser-initiated unsafe requests. (optional) (default to null)

// Get bulk database statistics
[apiInstance dbBulkStatsWith:bulkDatabaseStatsRequest
    xRequestedWith:xRequestedWith
              completionHandler: ^(db_bulk_stats_200_response output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var DomainFlowApi = require('domain_flow_api');
var defaultClient = DomainFlowApi.ApiClient.instance;

// Configure API key authorization: cookieAuth
var cookieAuth = defaultClient.authentications['cookieAuth'];
cookieAuth.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//cookieAuth.apiKeyPrefix['domainflow_session'] = "Token";

// Create an instance of the API class
var api = new DomainFlowApi.DatabaseApi()
var bulkDatabaseStatsRequest = ; // {BulkDatabaseStatsRequest} 
var opts = {
  'xRequestedWith': xRequestedWith_example // {String} CSRF/XHR sentinel header. Must be exactly "XMLHttpRequest" for browser-initiated unsafe requests.
};

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.dbBulkStats(bulkDatabaseStatsRequest, opts, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class dbBulkStatsExample
    {
        public void main()
        {
            // Configure API key authorization: cookieAuth
            Configuration.Default.ApiKey.Add("domainflow_session", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("domainflow_session", "Bearer");

            // Create an instance of the API class
            var apiInstance = new DatabaseApi();
            var bulkDatabaseStatsRequest = new BulkDatabaseStatsRequest(); // BulkDatabaseStatsRequest | 
            var xRequestedWith = xRequestedWith_example;  // String | CSRF/XHR sentinel header. Must be exactly "XMLHttpRequest" for browser-initiated unsafe requests. (optional)  (default to null)

            try {
                // Get bulk database statistics
                db_bulk_stats_200_response result = apiInstance.dbBulkStats(bulkDatabaseStatsRequest, xRequestedWith);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling DatabaseApi.dbBulkStats: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure API key authorization: cookieAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('domainflow_session', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('domainflow_session', 'Bearer');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\DatabaseApi();
$bulkDatabaseStatsRequest = ; // BulkDatabaseStatsRequest | 
$xRequestedWith = xRequestedWith_example; // String | CSRF/XHR sentinel header. Must be exactly "XMLHttpRequest" for browser-initiated unsafe requests.

try {
    $result = $api_instance->dbBulkStats($bulkDatabaseStatsRequest, $xRequestedWith);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling DatabaseApi->dbBulkStats: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::DatabaseApi;

# Configure API key authorization: cookieAuth
$WWW::OPenAPIClient::Configuration::api_key->{'domainflow_session'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'domainflow_session'} = "Bearer";

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::DatabaseApi->new();
my $bulkDatabaseStatsRequest = WWW::OPenAPIClient::Object::BulkDatabaseStatsRequest->new(); # BulkDatabaseStatsRequest | 
my $xRequestedWith = xRequestedWith_example; # String | CSRF/XHR sentinel header. Must be exactly "XMLHttpRequest" for browser-initiated unsafe requests.

eval {
    my $result = $api_instance->dbBulkStats(bulkDatabaseStatsRequest => $bulkDatabaseStatsRequest, xRequestedWith => $xRequestedWith);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling DatabaseApi->dbBulkStats: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure API key authorization: cookieAuth
openapi_client.configuration.api_key['domainflow_session'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['domainflow_session'] = 'Bearer'

# Create an instance of the API class
api_instance = openapi_client.DatabaseApi()
bulkDatabaseStatsRequest =  # BulkDatabaseStatsRequest | 
xRequestedWith = xRequestedWith_example # String | CSRF/XHR sentinel header. Must be exactly "XMLHttpRequest" for browser-initiated unsafe requests. (optional) (default to null)

try:
    # Get bulk database statistics
    api_response = api_instance.db_bulk_stats(bulkDatabaseStatsRequest, xRequestedWith=xRequestedWith)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DatabaseApi->dbBulkStats: %s\n" % e)
extern crate DatabaseApi;

pub fn main() {
    let bulkDatabaseStatsRequest = ; // BulkDatabaseStatsRequest
    let xRequestedWith = xRequestedWith_example; // String

    let mut context = DatabaseApi::Context::default();
    let result = client.dbBulkStats(bulkDatabaseStatsRequest, xRequestedWith, &context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Header parameters
Name Description
X-Requested-With
String
CSRF/XHR sentinel header. Must be exactly "XMLHttpRequest" for browser-initiated unsafe requests.
Body parameters
Name Description
bulkDatabaseStatsRequest *

Responses

Name Type Format Description
Retry-After Integer Seconds to wait before retrying


FeatureFlags

featureFlagsGet

Get feature flags


/config/features

Usage and SDK Samples

curl -X GET \
 \
 -H "Accept: application/json" \
 "https://api.domainflow.dev/api/v2/config/features"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.FeatureFlagsApi;

import java.io.File;
import java.util.*;

public class FeatureFlagsApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure API key authorization: cookieAuth
        ApiKeyAuth cookieAuth = (ApiKeyAuth) defaultClient.getAuthentication("cookieAuth");
        cookieAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //cookieAuth.setApiKeyPrefix("Token");

        // Create an instance of the API class
        FeatureFlagsApi apiInstance = new FeatureFlagsApi();

        try {
            feature_flags_get_200_response result = apiInstance.featureFlagsGet();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling FeatureFlagsApi#featureFlagsGet");
            e.printStackTrace();
        }
    }
}
import 'package:openapi/api.dart';

final api_instance = DefaultApi();


try {
    final result = await api_instance.featureFlagsGet();
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->featureFlagsGet: $e\n');
}

import org.openapitools.client.api.FeatureFlagsApi;

public class FeatureFlagsApiExample {
    public static void main(String[] args) {
        FeatureFlagsApi apiInstance = new FeatureFlagsApi();

        try {
            feature_flags_get_200_response result = apiInstance.featureFlagsGet();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling FeatureFlagsApi#featureFlagsGet");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: cookieAuth)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"domainflow_session"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"domainflow_session"];


// Create an instance of the API class
FeatureFlagsApi *apiInstance = [[FeatureFlagsApi alloc] init];

// Get feature flags
[apiInstance featureFlagsGetWithCompletionHandler: 
              ^(feature_flags_get_200_response output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var DomainFlowApi = require('domain_flow_api');
var defaultClient = DomainFlowApi.ApiClient.instance;

// Configure API key authorization: cookieAuth
var cookieAuth = defaultClient.authentications['cookieAuth'];
cookieAuth.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//cookieAuth.apiKeyPrefix['domainflow_session'] = "Token";

// Create an instance of the API class
var api = new DomainFlowApi.FeatureFlagsApi()
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.featureFlagsGet(callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class featureFlagsGetExample
    {
        public void main()
        {
            // Configure API key authorization: cookieAuth
            Configuration.Default.ApiKey.Add("domainflow_session", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("domainflow_session", "Bearer");

            // Create an instance of the API class
            var apiInstance = new FeatureFlagsApi();

            try {
                // Get feature flags
                feature_flags_get_200_response result = apiInstance.featureFlagsGet();
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling FeatureFlagsApi.featureFlagsGet: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure API key authorization: cookieAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('domainflow_session', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('domainflow_session', 'Bearer');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\FeatureFlagsApi();

try {
    $result = $api_instance->featureFlagsGet();
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling FeatureFlagsApi->featureFlagsGet: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::FeatureFlagsApi;

# Configure API key authorization: cookieAuth
$WWW::OPenAPIClient::Configuration::api_key->{'domainflow_session'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'domainflow_session'} = "Bearer";

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::FeatureFlagsApi->new();

eval {
    my $result = $api_instance->featureFlagsGet();
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling FeatureFlagsApi->featureFlagsGet: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure API key authorization: cookieAuth
openapi_client.configuration.api_key['domainflow_session'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['domainflow_session'] = 'Bearer'

# Create an instance of the API class
api_instance = openapi_client.FeatureFlagsApi()

try:
    # Get feature flags
    api_response = api_instance.feature_flags_get()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling FeatureFlagsApi->featureFlagsGet: %s\n" % e)
extern crate FeatureFlagsApi;

pub fn main() {

    let mut context = FeatureFlagsApi::Context::default();
    let result = client.featureFlagsGet(&context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Responses

Name Type Format Description
Retry-After Integer Seconds to wait before retrying


featureFlagsUpdate

Update feature flags


/config/features

Usage and SDK Samples

curl -X PUT \
 \
 -H "Accept: application/json" \
 -H "Content-Type: application/json" \
 "https://api.domainflow.dev/api/v2/config/features" \
 -d ''
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.FeatureFlagsApi;

import java.io.File;
import java.util.*;

public class FeatureFlagsApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure API key authorization: cookieAuth
        ApiKeyAuth cookieAuth = (ApiKeyAuth) defaultClient.getAuthentication("cookieAuth");
        cookieAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //cookieAuth.setApiKeyPrefix("Token");

        // Create an instance of the API class
        FeatureFlagsApi apiInstance = new FeatureFlagsApi();
        map[String, Boolean] requestBody = Object; // map[String, Boolean] | 

        try {
            feature_flags_get_200_response result = apiInstance.featureFlagsUpdate(requestBody);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling FeatureFlagsApi#featureFlagsUpdate");
            e.printStackTrace();
        }
    }
}
import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final map[String, Boolean] requestBody = new map[String, Boolean](); // map[String, Boolean] | 

try {
    final result = await api_instance.featureFlagsUpdate(requestBody);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->featureFlagsUpdate: $e\n');
}

import org.openapitools.client.api.FeatureFlagsApi;

public class FeatureFlagsApiExample {
    public static void main(String[] args) {
        FeatureFlagsApi apiInstance = new FeatureFlagsApi();
        map[String, Boolean] requestBody = Object; // map[String, Boolean] | 

        try {
            feature_flags_get_200_response result = apiInstance.featureFlagsUpdate(requestBody);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling FeatureFlagsApi#featureFlagsUpdate");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: cookieAuth)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"domainflow_session"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"domainflow_session"];


// Create an instance of the API class
FeatureFlagsApi *apiInstance = [[FeatureFlagsApi alloc] init];
map[String, Boolean] *requestBody = Object; // 

// Update feature flags
[apiInstance featureFlagsUpdateWith:requestBody
              completionHandler: ^(feature_flags_get_200_response output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var DomainFlowApi = require('domain_flow_api');
var defaultClient = DomainFlowApi.ApiClient.instance;

// Configure API key authorization: cookieAuth
var cookieAuth = defaultClient.authentications['cookieAuth'];
cookieAuth.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//cookieAuth.apiKeyPrefix['domainflow_session'] = "Token";

// Create an instance of the API class
var api = new DomainFlowApi.FeatureFlagsApi()
var requestBody = Object; // {map[String, Boolean]} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.featureFlagsUpdate(requestBody, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class featureFlagsUpdateExample
    {
        public void main()
        {
            // Configure API key authorization: cookieAuth
            Configuration.Default.ApiKey.Add("domainflow_session", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("domainflow_session", "Bearer");

            // Create an instance of the API class
            var apiInstance = new FeatureFlagsApi();
            var requestBody = new map[String, Boolean](); // map[String, Boolean] | 

            try {
                // Update feature flags
                feature_flags_get_200_response result = apiInstance.featureFlagsUpdate(requestBody);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling FeatureFlagsApi.featureFlagsUpdate: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure API key authorization: cookieAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('domainflow_session', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('domainflow_session', 'Bearer');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\FeatureFlagsApi();
$requestBody = Object; // map[String, Boolean] | 

try {
    $result = $api_instance->featureFlagsUpdate($requestBody);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling FeatureFlagsApi->featureFlagsUpdate: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::FeatureFlagsApi;

# Configure API key authorization: cookieAuth
$WWW::OPenAPIClient::Configuration::api_key->{'domainflow_session'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'domainflow_session'} = "Bearer";

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::FeatureFlagsApi->new();
my $requestBody = WWW::OPenAPIClient::Object::map[String, Boolean]->new(); # map[String, Boolean] | 

eval {
    my $result = $api_instance->featureFlagsUpdate(requestBody => $requestBody);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling FeatureFlagsApi->featureFlagsUpdate: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure API key authorization: cookieAuth
openapi_client.configuration.api_key['domainflow_session'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['domainflow_session'] = 'Bearer'

# Create an instance of the API class
api_instance = openapi_client.FeatureFlagsApi()
requestBody = Object # map[String, Boolean] | 

try:
    # Update feature flags
    api_response = api_instance.feature_flags_update(requestBody)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling FeatureFlagsApi->featureFlagsUpdate: %s\n" % e)
extern crate FeatureFlagsApi;

pub fn main() {
    let requestBody = Object; // map[String, Boolean]

    let mut context = FeatureFlagsApi::Context::default();
    let result = client.featureFlagsUpdate(requestBody, &context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Body parameters
Name Description
requestBody *

Responses

Name Type Format Description
Retry-After Integer Seconds to wait before retrying


Health

healthCheck

Health check


/health

Usage and SDK Samples

curl -X GET \
 \
 -H "Accept: application/json" \
 "https://api.domainflow.dev/api/v2/health"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.HealthApi;

import java.io.File;
import java.util.*;

public class HealthApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure API key authorization: cookieAuth
        ApiKeyAuth cookieAuth = (ApiKeyAuth) defaultClient.getAuthentication("cookieAuth");
        cookieAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //cookieAuth.setApiKeyPrefix("Token");

        // Create an instance of the API class
        HealthApi apiInstance = new HealthApi();

        try {
            SuccessEnvelope result = apiInstance.healthCheck();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling HealthApi#healthCheck");
            e.printStackTrace();
        }
    }
}
import 'package:openapi/api.dart';

final api_instance = DefaultApi();


try {
    final result = await api_instance.healthCheck();
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->healthCheck: $e\n');
}

import org.openapitools.client.api.HealthApi;

public class HealthApiExample {
    public static void main(String[] args) {
        HealthApi apiInstance = new HealthApi();

        try {
            SuccessEnvelope result = apiInstance.healthCheck();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling HealthApi#healthCheck");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: cookieAuth)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"domainflow_session"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"domainflow_session"];


// Create an instance of the API class
HealthApi *apiInstance = [[HealthApi alloc] init];

// Health check
[apiInstance healthCheckWithCompletionHandler: 
              ^(SuccessEnvelope output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var DomainFlowApi = require('domain_flow_api');
var defaultClient = DomainFlowApi.ApiClient.instance;

// Configure API key authorization: cookieAuth
var cookieAuth = defaultClient.authentications['cookieAuth'];
cookieAuth.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//cookieAuth.apiKeyPrefix['domainflow_session'] = "Token";

// Create an instance of the API class
var api = new DomainFlowApi.HealthApi()
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.healthCheck(callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class healthCheckExample
    {
        public void main()
        {
            // Configure API key authorization: cookieAuth
            Configuration.Default.ApiKey.Add("domainflow_session", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("domainflow_session", "Bearer");

            // Create an instance of the API class
            var apiInstance = new HealthApi();

            try {
                // Health check
                SuccessEnvelope result = apiInstance.healthCheck();
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling HealthApi.healthCheck: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure API key authorization: cookieAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('domainflow_session', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('domainflow_session', 'Bearer');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\HealthApi();

try {
    $result = $api_instance->healthCheck();
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling HealthApi->healthCheck: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::HealthApi;

# Configure API key authorization: cookieAuth
$WWW::OPenAPIClient::Configuration::api_key->{'domainflow_session'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'domainflow_session'} = "Bearer";

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::HealthApi->new();

eval {
    my $result = $api_instance->healthCheck();
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling HealthApi->healthCheck: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure API key authorization: cookieAuth
openapi_client.configuration.api_key['domainflow_session'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['domainflow_session'] = 'Bearer'

# Create an instance of the API class
api_instance = openapi_client.HealthApi()

try:
    # Health check
    api_response = api_instance.health_check()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling HealthApi->healthCheck: %s\n" % e)
extern crate HealthApi;

pub fn main() {

    let mut context = HealthApi::Context::default();
    let result = client.healthCheck(&context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Responses

Name Type Format Description
Retry-After Integer Seconds to wait before retrying


healthLive

Liveness check


/health/live

Usage and SDK Samples

curl -X GET \
 \
 -H "Accept: application/json" \
 "https://api.domainflow.dev/api/v2/health/live"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.HealthApi;

import java.io.File;
import java.util.*;

public class HealthApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure API key authorization: cookieAuth
        ApiKeyAuth cookieAuth = (ApiKeyAuth) defaultClient.getAuthentication("cookieAuth");
        cookieAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //cookieAuth.setApiKeyPrefix("Token");

        // Create an instance of the API class
        HealthApi apiInstance = new HealthApi();

        try {
            SuccessEnvelope result = apiInstance.healthLive();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling HealthApi#healthLive");
            e.printStackTrace();
        }
    }
}
import 'package:openapi/api.dart';

final api_instance = DefaultApi();


try {
    final result = await api_instance.healthLive();
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->healthLive: $e\n');
}

import org.openapitools.client.api.HealthApi;

public class HealthApiExample {
    public static void main(String[] args) {
        HealthApi apiInstance = new HealthApi();

        try {
            SuccessEnvelope result = apiInstance.healthLive();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling HealthApi#healthLive");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: cookieAuth)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"domainflow_session"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"domainflow_session"];


// Create an instance of the API class
HealthApi *apiInstance = [[HealthApi alloc] init];

// Liveness check
[apiInstance healthLiveWithCompletionHandler: 
              ^(SuccessEnvelope output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var DomainFlowApi = require('domain_flow_api');
var defaultClient = DomainFlowApi.ApiClient.instance;

// Configure API key authorization: cookieAuth
var cookieAuth = defaultClient.authentications['cookieAuth'];
cookieAuth.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//cookieAuth.apiKeyPrefix['domainflow_session'] = "Token";

// Create an instance of the API class
var api = new DomainFlowApi.HealthApi()
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.healthLive(callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class healthLiveExample
    {
        public void main()
        {
            // Configure API key authorization: cookieAuth
            Configuration.Default.ApiKey.Add("domainflow_session", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("domainflow_session", "Bearer");

            // Create an instance of the API class
            var apiInstance = new HealthApi();

            try {
                // Liveness check
                SuccessEnvelope result = apiInstance.healthLive();
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling HealthApi.healthLive: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure API key authorization: cookieAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('domainflow_session', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('domainflow_session', 'Bearer');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\HealthApi();

try {
    $result = $api_instance->healthLive();
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling HealthApi->healthLive: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::HealthApi;

# Configure API key authorization: cookieAuth
$WWW::OPenAPIClient::Configuration::api_key->{'domainflow_session'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'domainflow_session'} = "Bearer";

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::HealthApi->new();

eval {
    my $result = $api_instance->healthLive();
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling HealthApi->healthLive: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure API key authorization: cookieAuth
openapi_client.configuration.api_key['domainflow_session'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['domainflow_session'] = 'Bearer'

# Create an instance of the API class
api_instance = openapi_client.HealthApi()

try:
    # Liveness check
    api_response = api_instance.health_live()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling HealthApi->healthLive: %s\n" % e)
extern crate HealthApi;

pub fn main() {

    let mut context = HealthApi::Context::default();
    let result = client.healthLive(&context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Responses

Name Type Format Description
Retry-After Integer Seconds to wait before retrying


healthReady

Readiness check


/health/ready

Usage and SDK Samples

curl -X GET \
 \
 -H "Accept: application/json" \
 "https://api.domainflow.dev/api/v2/health/ready"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.HealthApi;

import java.io.File;
import java.util.*;

public class HealthApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure API key authorization: cookieAuth
        ApiKeyAuth cookieAuth = (ApiKeyAuth) defaultClient.getAuthentication("cookieAuth");
        cookieAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //cookieAuth.setApiKeyPrefix("Token");

        // Create an instance of the API class
        HealthApi apiInstance = new HealthApi();

        try {
            SuccessEnvelope result = apiInstance.healthReady();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling HealthApi#healthReady");
            e.printStackTrace();
        }
    }
}
import 'package:openapi/api.dart';

final api_instance = DefaultApi();


try {
    final result = await api_instance.healthReady();
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->healthReady: $e\n');
}

import org.openapitools.client.api.HealthApi;

public class HealthApiExample {
    public static void main(String[] args) {
        HealthApi apiInstance = new HealthApi();

        try {
            SuccessEnvelope result = apiInstance.healthReady();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling HealthApi#healthReady");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: cookieAuth)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"domainflow_session"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"domainflow_session"];


// Create an instance of the API class
HealthApi *apiInstance = [[HealthApi alloc] init];

// Readiness check
[apiInstance healthReadyWithCompletionHandler: 
              ^(SuccessEnvelope output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var DomainFlowApi = require('domain_flow_api');
var defaultClient = DomainFlowApi.ApiClient.instance;

// Configure API key authorization: cookieAuth
var cookieAuth = defaultClient.authentications['cookieAuth'];
cookieAuth.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//cookieAuth.apiKeyPrefix['domainflow_session'] = "Token";

// Create an instance of the API class
var api = new DomainFlowApi.HealthApi()
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.healthReady(callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class healthReadyExample
    {
        public void main()
        {
            // Configure API key authorization: cookieAuth
            Configuration.Default.ApiKey.Add("domainflow_session", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("domainflow_session", "Bearer");

            // Create an instance of the API class
            var apiInstance = new HealthApi();

            try {
                // Readiness check
                SuccessEnvelope result = apiInstance.healthReady();
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling HealthApi.healthReady: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure API key authorization: cookieAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('domainflow_session', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('domainflow_session', 'Bearer');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\HealthApi();

try {
    $result = $api_instance->healthReady();
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling HealthApi->healthReady: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::HealthApi;

# Configure API key authorization: cookieAuth
$WWW::OPenAPIClient::Configuration::api_key->{'domainflow_session'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'domainflow_session'} = "Bearer";

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::HealthApi->new();

eval {
    my $result = $api_instance->healthReady();
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling HealthApi->healthReady: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure API key authorization: cookieAuth
openapi_client.configuration.api_key['domainflow_session'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['domainflow_session'] = 'Bearer'

# Create an instance of the API class
api_instance = openapi_client.HealthApi()

try:
    # Readiness check
    api_response = api_instance.health_ready()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling HealthApi->healthReady: %s\n" % e)
extern crate HealthApi;

pub fn main() {

    let mut context = HealthApi::Context::default();
    let result = client.healthReady(&context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Responses

Name Type Format Description
Retry-After Integer Seconds to wait before retrying


ping

Ping server


/ping

Usage and SDK Samples

curl -X GET \
 \
 -H "Accept: application/json" \
 "https://api.domainflow.dev/api/v2/ping"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.HealthApi;

import java.io.File;
import java.util.*;

public class HealthApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure API key authorization: cookieAuth
        ApiKeyAuth cookieAuth = (ApiKeyAuth) defaultClient.getAuthentication("cookieAuth");
        cookieAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //cookieAuth.setApiKeyPrefix("Token");

        // Create an instance of the API class
        HealthApi apiInstance = new HealthApi();

        try {
            SuccessEnvelope result = apiInstance.ping();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling HealthApi#ping");
            e.printStackTrace();
        }
    }
}
import 'package:openapi/api.dart';

final api_instance = DefaultApi();


try {
    final result = await api_instance.ping();
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->ping: $e\n');
}

import org.openapitools.client.api.HealthApi;

public class HealthApiExample {
    public static void main(String[] args) {
        HealthApi apiInstance = new HealthApi();

        try {
            SuccessEnvelope result = apiInstance.ping();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling HealthApi#ping");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: cookieAuth)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"domainflow_session"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"domainflow_session"];


// Create an instance of the API class
HealthApi *apiInstance = [[HealthApi alloc] init];

// Ping server
[apiInstance pingWithCompletionHandler: 
              ^(SuccessEnvelope output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var DomainFlowApi = require('domain_flow_api');
var defaultClient = DomainFlowApi.ApiClient.instance;

// Configure API key authorization: cookieAuth
var cookieAuth = defaultClient.authentications['cookieAuth'];
cookieAuth.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//cookieAuth.apiKeyPrefix['domainflow_session'] = "Token";

// Create an instance of the API class
var api = new DomainFlowApi.HealthApi()
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.ping(callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class pingExample
    {
        public void main()
        {
            // Configure API key authorization: cookieAuth
            Configuration.Default.ApiKey.Add("domainflow_session", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("domainflow_session", "Bearer");

            // Create an instance of the API class
            var apiInstance = new HealthApi();

            try {
                // Ping server
                SuccessEnvelope result = apiInstance.ping();
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling HealthApi.ping: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure API key authorization: cookieAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('domainflow_session', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('domainflow_session', 'Bearer');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\HealthApi();

try {
    $result = $api_instance->ping();
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling HealthApi->ping: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::HealthApi;

# Configure API key authorization: cookieAuth
$WWW::OPenAPIClient::Configuration::api_key->{'domainflow_session'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'domainflow_session'} = "Bearer";

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::HealthApi->new();

eval {
    my $result = $api_instance->ping();
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling HealthApi->ping: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure API key authorization: cookieAuth
openapi_client.configuration.api_key['domainflow_session'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['domainflow_session'] = 'Bearer'

# Create an instance of the API class
api_instance = openapi_client.HealthApi()

try:
    # Ping server
    api_response = api_instance.ping()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling HealthApi->ping: %s\n" % e)
extern crate HealthApi;

pub fn main() {

    let mut context = HealthApi::Context::default();
    let result = client.ping(&context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Responses

Name Type Format Description
Retry-After Integer Seconds to wait before retrying


KeywordExtraction

keywordExtractBatch

Batch keyword extraction


/extract/keywords

Usage and SDK Samples

curl -X POST \
 \
 -H "Accept: application/json" \
 -H "Content-Type: application/json" \
 "https://api.domainflow.dev/api/v2/extract/keywords" \
 -d '{
  "items" : [ {
    "httpPersonaId" : "046b6c7f-0b8a-43b9-b35d-6489e6daee91",
    "keywordSetId" : "046b6c7f-0b8a-43b9-b35d-6489e6daee91",
    "dnsPersonaId" : "046b6c7f-0b8a-43b9-b35d-6489e6daee91",
    "url" : "https://openapi-generator.tech"
  }, {
    "httpPersonaId" : "046b6c7f-0b8a-43b9-b35d-6489e6daee91",
    "keywordSetId" : "046b6c7f-0b8a-43b9-b35d-6489e6daee91",
    "dnsPersonaId" : "046b6c7f-0b8a-43b9-b35d-6489e6daee91",
    "url" : "https://openapi-generator.tech"
  } ]
}'
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.KeywordExtractionApi;

import java.io.File;
import java.util.*;

public class KeywordExtractionApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure API key authorization: cookieAuth
        ApiKeyAuth cookieAuth = (ApiKeyAuth) defaultClient.getAuthentication("cookieAuth");
        cookieAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //cookieAuth.setApiKeyPrefix("Token");

        // Create an instance of the API class
        KeywordExtractionApi apiInstance = new KeywordExtractionApi();
        BatchKeywordExtractionRequest batchKeywordExtractionRequest = ; // BatchKeywordExtractionRequest | 

        try {
            keyword_extract_batch_200_response result = apiInstance.keywordExtractBatch(batchKeywordExtractionRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling KeywordExtractionApi#keywordExtractBatch");
            e.printStackTrace();
        }
    }
}
import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final BatchKeywordExtractionRequest batchKeywordExtractionRequest = new BatchKeywordExtractionRequest(); // BatchKeywordExtractionRequest | 

try {
    final result = await api_instance.keywordExtractBatch(batchKeywordExtractionRequest);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->keywordExtractBatch: $e\n');
}

import org.openapitools.client.api.KeywordExtractionApi;

public class KeywordExtractionApiExample {
    public static void main(String[] args) {
        KeywordExtractionApi apiInstance = new KeywordExtractionApi();
        BatchKeywordExtractionRequest batchKeywordExtractionRequest = ; // BatchKeywordExtractionRequest | 

        try {
            keyword_extract_batch_200_response result = apiInstance.keywordExtractBatch(batchKeywordExtractionRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling KeywordExtractionApi#keywordExtractBatch");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: cookieAuth)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"domainflow_session"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"domainflow_session"];


// Create an instance of the API class
KeywordExtractionApi *apiInstance = [[KeywordExtractionApi alloc] init];
BatchKeywordExtractionRequest *batchKeywordExtractionRequest = ; // 

// Batch keyword extraction
[apiInstance keywordExtractBatchWith:batchKeywordExtractionRequest
              completionHandler: ^(keyword_extract_batch_200_response output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var DomainFlowApi = require('domain_flow_api');
var defaultClient = DomainFlowApi.ApiClient.instance;

// Configure API key authorization: cookieAuth
var cookieAuth = defaultClient.authentications['cookieAuth'];
cookieAuth.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//cookieAuth.apiKeyPrefix['domainflow_session'] = "Token";

// Create an instance of the API class
var api = new DomainFlowApi.KeywordExtractionApi()
var batchKeywordExtractionRequest = ; // {BatchKeywordExtractionRequest} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.keywordExtractBatch(batchKeywordExtractionRequest, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class keywordExtractBatchExample
    {
        public void main()
        {
            // Configure API key authorization: cookieAuth
            Configuration.Default.ApiKey.Add("domainflow_session", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("domainflow_session", "Bearer");

            // Create an instance of the API class
            var apiInstance = new KeywordExtractionApi();
            var batchKeywordExtractionRequest = new BatchKeywordExtractionRequest(); // BatchKeywordExtractionRequest | 

            try {
                // Batch keyword extraction
                keyword_extract_batch_200_response result = apiInstance.keywordExtractBatch(batchKeywordExtractionRequest);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling KeywordExtractionApi.keywordExtractBatch: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure API key authorization: cookieAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('domainflow_session', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('domainflow_session', 'Bearer');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\KeywordExtractionApi();
$batchKeywordExtractionRequest = ; // BatchKeywordExtractionRequest | 

try {
    $result = $api_instance->keywordExtractBatch($batchKeywordExtractionRequest);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling KeywordExtractionApi->keywordExtractBatch: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::KeywordExtractionApi;

# Configure API key authorization: cookieAuth
$WWW::OPenAPIClient::Configuration::api_key->{'domainflow_session'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'domainflow_session'} = "Bearer";

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::KeywordExtractionApi->new();
my $batchKeywordExtractionRequest = WWW::OPenAPIClient::Object::BatchKeywordExtractionRequest->new(); # BatchKeywordExtractionRequest | 

eval {
    my $result = $api_instance->keywordExtractBatch(batchKeywordExtractionRequest => $batchKeywordExtractionRequest);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling KeywordExtractionApi->keywordExtractBatch: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure API key authorization: cookieAuth
openapi_client.configuration.api_key['domainflow_session'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['domainflow_session'] = 'Bearer'

# Create an instance of the API class
api_instance = openapi_client.KeywordExtractionApi()
batchKeywordExtractionRequest =  # BatchKeywordExtractionRequest | 

try:
    # Batch keyword extraction
    api_response = api_instance.keyword_extract_batch(batchKeywordExtractionRequest)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling KeywordExtractionApi->keywordExtractBatch: %s\n" % e)
extern crate KeywordExtractionApi;

pub fn main() {
    let batchKeywordExtractionRequest = ; // BatchKeywordExtractionRequest

    let mut context = KeywordExtractionApi::Context::default();
    let result = client.keywordExtractBatch(batchKeywordExtractionRequest, &context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Body parameters
Name Description
batchKeywordExtractionRequest *

Responses

Name Type Format Description
Retry-After Integer Seconds to wait before retrying


keywordExtractStream

Stream keyword extraction

Server-Sent Events stream. Clients SHOULD handle heartbeats and reconnection hints. Heartbeat events are sent periodically: - see example SseHeartbeat; clients SHOULD keep the connection alive. The server MAY suggest a retry delay with an SSE control line (see SseRetry example).


/extract/keywords/stream

Usage and SDK Samples

curl -X GET \
 \
 -H "Accept: text/event-stream,application/json" \
 "https://api.domainflow.dev/api/v2/extract/keywords/stream?url=url_example&keywordSetId=38400000-8cf0-11bd-b23e-10b96e4ef00d&httpPersonaId=38400000-8cf0-11bd-b23e-10b96e4ef00d&dnsPersonaId=38400000-8cf0-11bd-b23e-10b96e4ef00d"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.KeywordExtractionApi;

import java.io.File;
import java.util.*;

public class KeywordExtractionApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure API key authorization: cookieAuth
        ApiKeyAuth cookieAuth = (ApiKeyAuth) defaultClient.getAuthentication("cookieAuth");
        cookieAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //cookieAuth.setApiKeyPrefix("Token");

        // Create an instance of the API class
        KeywordExtractionApi apiInstance = new KeywordExtractionApi();
        URI url = url_example; // URI | 
        UUID keywordSetId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 
        UUID httpPersonaId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 
        UUID dnsPersonaId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 

        try {
            'String' result = apiInstance.keywordExtractStream(url, keywordSetId, httpPersonaId, dnsPersonaId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling KeywordExtractionApi#keywordExtractStream");
            e.printStackTrace();
        }
    }
}
import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final URI url = new URI(); // URI | 
final UUID keywordSetId = new UUID(); // UUID | 
final UUID httpPersonaId = new UUID(); // UUID | 
final UUID dnsPersonaId = new UUID(); // UUID | 

try {
    final result = await api_instance.keywordExtractStream(url, keywordSetId, httpPersonaId, dnsPersonaId);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->keywordExtractStream: $e\n');
}

import org.openapitools.client.api.KeywordExtractionApi;

public class KeywordExtractionApiExample {
    public static void main(String[] args) {
        KeywordExtractionApi apiInstance = new KeywordExtractionApi();
        URI url = url_example; // URI | 
        UUID keywordSetId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 
        UUID httpPersonaId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 
        UUID dnsPersonaId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 

        try {
            'String' result = apiInstance.keywordExtractStream(url, keywordSetId, httpPersonaId, dnsPersonaId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling KeywordExtractionApi#keywordExtractStream");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: cookieAuth)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"domainflow_session"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"domainflow_session"];


// Create an instance of the API class
KeywordExtractionApi *apiInstance = [[KeywordExtractionApi alloc] init];
URI *url = url_example; //  (default to null)
UUID *keywordSetId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; //  (default to null)
UUID *httpPersonaId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; //  (optional) (default to null)
UUID *dnsPersonaId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; //  (optional) (default to null)

// Stream keyword extraction
[apiInstance keywordExtractStreamWith:url
    keywordSetId:keywordSetId
    httpPersonaId:httpPersonaId
    dnsPersonaId:dnsPersonaId
              completionHandler: ^('String' output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var DomainFlowApi = require('domain_flow_api');
var defaultClient = DomainFlowApi.ApiClient.instance;

// Configure API key authorization: cookieAuth
var cookieAuth = defaultClient.authentications['cookieAuth'];
cookieAuth.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//cookieAuth.apiKeyPrefix['domainflow_session'] = "Token";

// Create an instance of the API class
var api = new DomainFlowApi.KeywordExtractionApi()
var url = url_example; // {URI} 
var keywordSetId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // {UUID} 
var opts = {
  'httpPersonaId': 38400000-8cf0-11bd-b23e-10b96e4ef00d, // {UUID} 
  'dnsPersonaId': 38400000-8cf0-11bd-b23e-10b96e4ef00d // {UUID} 
};

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.keywordExtractStream(url, keywordSetId, opts, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class keywordExtractStreamExample
    {
        public void main()
        {
            // Configure API key authorization: cookieAuth
            Configuration.Default.ApiKey.Add("domainflow_session", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("domainflow_session", "Bearer");

            // Create an instance of the API class
            var apiInstance = new KeywordExtractionApi();
            var url = url_example;  // URI |  (default to null)
            var keywordSetId = 38400000-8cf0-11bd-b23e-10b96e4ef00d;  // UUID |  (default to null)
            var httpPersonaId = 38400000-8cf0-11bd-b23e-10b96e4ef00d;  // UUID |  (optional)  (default to null)
            var dnsPersonaId = 38400000-8cf0-11bd-b23e-10b96e4ef00d;  // UUID |  (optional)  (default to null)

            try {
                // Stream keyword extraction
                'String' result = apiInstance.keywordExtractStream(url, keywordSetId, httpPersonaId, dnsPersonaId);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling KeywordExtractionApi.keywordExtractStream: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure API key authorization: cookieAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('domainflow_session', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('domainflow_session', 'Bearer');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\KeywordExtractionApi();
$url = url_example; // URI | 
$keywordSetId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 
$httpPersonaId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 
$dnsPersonaId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 

try {
    $result = $api_instance->keywordExtractStream($url, $keywordSetId, $httpPersonaId, $dnsPersonaId);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling KeywordExtractionApi->keywordExtractStream: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::KeywordExtractionApi;

# Configure API key authorization: cookieAuth
$WWW::OPenAPIClient::Configuration::api_key->{'domainflow_session'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'domainflow_session'} = "Bearer";

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::KeywordExtractionApi->new();
my $url = url_example; # URI | 
my $keywordSetId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; # UUID | 
my $httpPersonaId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; # UUID | 
my $dnsPersonaId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; # UUID | 

eval {
    my $result = $api_instance->keywordExtractStream(url => $url, keywordSetId => $keywordSetId, httpPersonaId => $httpPersonaId, dnsPersonaId => $dnsPersonaId);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling KeywordExtractionApi->keywordExtractStream: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure API key authorization: cookieAuth
openapi_client.configuration.api_key['domainflow_session'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['domainflow_session'] = 'Bearer'

# Create an instance of the API class
api_instance = openapi_client.KeywordExtractionApi()
url = url_example # URI |  (default to null)
keywordSetId = 38400000-8cf0-11bd-b23e-10b96e4ef00d # UUID |  (default to null)
httpPersonaId = 38400000-8cf0-11bd-b23e-10b96e4ef00d # UUID |  (optional) (default to null)
dnsPersonaId = 38400000-8cf0-11bd-b23e-10b96e4ef00d # UUID |  (optional) (default to null)

try:
    # Stream keyword extraction
    api_response = api_instance.keyword_extract_stream(url, keywordSetId, httpPersonaId=httpPersonaId, dnsPersonaId=dnsPersonaId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling KeywordExtractionApi->keywordExtractStream: %s\n" % e)
extern crate KeywordExtractionApi;

pub fn main() {
    let url = url_example; // URI
    let keywordSetId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID
    let httpPersonaId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID
    let dnsPersonaId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID

    let mut context = KeywordExtractionApi::Context::default();
    let result = client.keywordExtractStream(url, keywordSetId, httpPersonaId, dnsPersonaId, &context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Query parameters
Name Description
url*
URI (uri)
Required
keywordSetId*
UUID (uuid)
Required
httpPersonaId
UUID (uuid)
dnsPersonaId
UUID (uuid)

Responses

Name Type Format Description
Retry-After Integer Seconds to wait before retrying


KeywordRules

keywordRulesQuery

Query keyword rules


/keyword-rules

Usage and SDK Samples

curl -X GET \
 \
 -H "Accept: application/json" \
 "https://api.domainflow.dev/api/v2/keyword-rules?limit=56&offset=56&keyword_set_id=38400000-8cf0-11bd-b23e-10b96e4ef00d&rule_type=&category=category_example&is_case_sensitive=true&pattern=pattern_example"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.KeywordRulesApi;

import java.io.File;
import java.util.*;

public class KeywordRulesApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure API key authorization: cookieAuth
        ApiKeyAuth cookieAuth = (ApiKeyAuth) defaultClient.getAuthentication("cookieAuth");
        cookieAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //cookieAuth.setApiKeyPrefix("Token");

        // Create an instance of the API class
        KeywordRulesApi apiInstance = new KeywordRulesApi();
        Integer limit = 56; // Integer | 
        Integer offset = 56; // Integer | 
        UUID keywordSetId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 
        KeywordRuleType ruleType = ; // KeywordRuleType | 
        String category = category_example; // String | 
        Boolean isCaseSensitive = true; // Boolean | 
        String pattern = pattern_example; // String | 

        try {
            keyword_sets_rules_list_200_response result = apiInstance.keywordRulesQuery(limit, offset, keywordSetId, ruleType, category, isCaseSensitive, pattern);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling KeywordRulesApi#keywordRulesQuery");
            e.printStackTrace();
        }
    }
}
import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final Integer limit = new Integer(); // Integer | 
final Integer offset = new Integer(); // Integer | 
final UUID keywordSetId = new UUID(); // UUID | 
final KeywordRuleType ruleType = new KeywordRuleType(); // KeywordRuleType | 
final String category = new String(); // String | 
final Boolean isCaseSensitive = new Boolean(); // Boolean | 
final String pattern = new String(); // String | 

try {
    final result = await api_instance.keywordRulesQuery(limit, offset, keywordSetId, ruleType, category, isCaseSensitive, pattern);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->keywordRulesQuery: $e\n');
}

import org.openapitools.client.api.KeywordRulesApi;

public class KeywordRulesApiExample {
    public static void main(String[] args) {
        KeywordRulesApi apiInstance = new KeywordRulesApi();
        Integer limit = 56; // Integer | 
        Integer offset = 56; // Integer | 
        UUID keywordSetId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 
        KeywordRuleType ruleType = ; // KeywordRuleType | 
        String category = category_example; // String | 
        Boolean isCaseSensitive = true; // Boolean | 
        String pattern = pattern_example; // String | 

        try {
            keyword_sets_rules_list_200_response result = apiInstance.keywordRulesQuery(limit, offset, keywordSetId, ruleType, category, isCaseSensitive, pattern);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling KeywordRulesApi#keywordRulesQuery");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: cookieAuth)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"domainflow_session"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"domainflow_session"];


// Create an instance of the API class
KeywordRulesApi *apiInstance = [[KeywordRulesApi alloc] init];
Integer *limit = 56; //  (optional) (default to 50)
Integer *offset = 56; //  (optional) (default to 0)
UUID *keywordSetId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; //  (optional) (default to null)
KeywordRuleType *ruleType = ; //  (optional) (default to null)
String *category = category_example; //  (optional) (default to null)
Boolean *isCaseSensitive = true; //  (optional) (default to null)
String *pattern = pattern_example; //  (optional) (default to null)

// Query keyword rules
[apiInstance keywordRulesQueryWith:limit
    offset:offset
    keywordSetId:keywordSetId
    ruleType:ruleType
    category:category
    isCaseSensitive:isCaseSensitive
    pattern:pattern
              completionHandler: ^(keyword_sets_rules_list_200_response output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var DomainFlowApi = require('domain_flow_api');
var defaultClient = DomainFlowApi.ApiClient.instance;

// Configure API key authorization: cookieAuth
var cookieAuth = defaultClient.authentications['cookieAuth'];
cookieAuth.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//cookieAuth.apiKeyPrefix['domainflow_session'] = "Token";

// Create an instance of the API class
var api = new DomainFlowApi.KeywordRulesApi()
var opts = {
  'limit': 56, // {Integer} 
  'offset': 56, // {Integer} 
  'keywordSetId': 38400000-8cf0-11bd-b23e-10b96e4ef00d, // {UUID} 
  'ruleType': , // {KeywordRuleType} 
  'category': category_example, // {String} 
  'isCaseSensitive': true, // {Boolean} 
  'pattern': pattern_example // {String} 
};

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.keywordRulesQuery(opts, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class keywordRulesQueryExample
    {
        public void main()
        {
            // Configure API key authorization: cookieAuth
            Configuration.Default.ApiKey.Add("domainflow_session", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("domainflow_session", "Bearer");

            // Create an instance of the API class
            var apiInstance = new KeywordRulesApi();
            var limit = 56;  // Integer |  (optional)  (default to 50)
            var offset = 56;  // Integer |  (optional)  (default to 0)
            var keywordSetId = 38400000-8cf0-11bd-b23e-10b96e4ef00d;  // UUID |  (optional)  (default to null)
            var ruleType = new KeywordRuleType(); // KeywordRuleType |  (optional)  (default to null)
            var category = category_example;  // String |  (optional)  (default to null)
            var isCaseSensitive = true;  // Boolean |  (optional)  (default to null)
            var pattern = pattern_example;  // String |  (optional)  (default to null)

            try {
                // Query keyword rules
                keyword_sets_rules_list_200_response result = apiInstance.keywordRulesQuery(limit, offset, keywordSetId, ruleType, category, isCaseSensitive, pattern);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling KeywordRulesApi.keywordRulesQuery: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure API key authorization: cookieAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('domainflow_session', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('domainflow_session', 'Bearer');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\KeywordRulesApi();
$limit = 56; // Integer | 
$offset = 56; // Integer | 
$keywordSetId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 
$ruleType = ; // KeywordRuleType | 
$category = category_example; // String | 
$isCaseSensitive = true; // Boolean | 
$pattern = pattern_example; // String | 

try {
    $result = $api_instance->keywordRulesQuery($limit, $offset, $keywordSetId, $ruleType, $category, $isCaseSensitive, $pattern);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling KeywordRulesApi->keywordRulesQuery: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::KeywordRulesApi;

# Configure API key authorization: cookieAuth
$WWW::OPenAPIClient::Configuration::api_key->{'domainflow_session'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'domainflow_session'} = "Bearer";

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::KeywordRulesApi->new();
my $limit = 56; # Integer | 
my $offset = 56; # Integer | 
my $keywordSetId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; # UUID | 
my $ruleType = ; # KeywordRuleType | 
my $category = category_example; # String | 
my $isCaseSensitive = true; # Boolean | 
my $pattern = pattern_example; # String | 

eval {
    my $result = $api_instance->keywordRulesQuery(limit => $limit, offset => $offset, keywordSetId => $keywordSetId, ruleType => $ruleType, category => $category, isCaseSensitive => $isCaseSensitive, pattern => $pattern);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling KeywordRulesApi->keywordRulesQuery: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure API key authorization: cookieAuth
openapi_client.configuration.api_key['domainflow_session'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['domainflow_session'] = 'Bearer'

# Create an instance of the API class
api_instance = openapi_client.KeywordRulesApi()
limit = 56 # Integer |  (optional) (default to 50)
offset = 56 # Integer |  (optional) (default to 0)
keywordSetId = 38400000-8cf0-11bd-b23e-10b96e4ef00d # UUID |  (optional) (default to null)
ruleType =  # KeywordRuleType |  (optional) (default to null)
category = category_example # String |  (optional) (default to null)
isCaseSensitive = true # Boolean |  (optional) (default to null)
pattern = pattern_example # String |  (optional) (default to null)

try:
    # Query keyword rules
    api_response = api_instance.keyword_rules_query(limit=limit, offset=offset, keywordSetId=keywordSetId, ruleType=ruleType, category=category, isCaseSensitive=isCaseSensitive, pattern=pattern)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling KeywordRulesApi->keywordRulesQuery: %s\n" % e)
extern crate KeywordRulesApi;

pub fn main() {
    let limit = 56; // Integer
    let offset = 56; // Integer
    let keywordSetId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID
    let ruleType = ; // KeywordRuleType
    let category = category_example; // String
    let isCaseSensitive = true; // Boolean
    let pattern = pattern_example; // String

    let mut context = KeywordRulesApi::Context::default();
    let result = client.keywordRulesQuery(limit, offset, keywordSetId, ruleType, category, isCaseSensitive, pattern, &context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Query parameters
Name Description
limit
Integer
offset
Integer
keyword_set_id
UUID (uuid)
rule_type
KeywordRuleType
category
String
is_case_sensitive
Boolean
pattern
String

Responses

Name Type Format Description
Retry-After Integer Seconds to wait before retrying


KeywordSets

keywordSetsCreate

Create keyword set


/keyword-sets

Usage and SDK Samples

curl -X POST \
 \
 -H "Accept: application/json" \
 -H "Content-Type: application/json" \
 "https://api.domainflow.dev/api/v2/keyword-sets" \
 -d '{
  "isEnabled" : true,
  "name" : "name",
  "description" : "description",
  "rules" : [ {
    "isCaseSensitive" : true,
    "ruleType" : "string",
    "pattern" : "pattern",
    "category" : "category",
    "contextChars" : 0
  }, {
    "isCaseSensitive" : true,
    "ruleType" : "string",
    "pattern" : "pattern",
    "category" : "category",
    "contextChars" : 0
  } ]
}'
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.KeywordSetsApi;

import java.io.File;
import java.util.*;

public class KeywordSetsApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure API key authorization: cookieAuth
        ApiKeyAuth cookieAuth = (ApiKeyAuth) defaultClient.getAuthentication("cookieAuth");
        cookieAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //cookieAuth.setApiKeyPrefix("Token");

        // Create an instance of the API class
        KeywordSetsApi apiInstance = new KeywordSetsApi();
        CreateKeywordSetRequest createKeywordSetRequest = ; // CreateKeywordSetRequest | 

        try {
            keyword_sets_create_201_response result = apiInstance.keywordSetsCreate(createKeywordSetRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling KeywordSetsApi#keywordSetsCreate");
            e.printStackTrace();
        }
    }
}
import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final CreateKeywordSetRequest createKeywordSetRequest = new CreateKeywordSetRequest(); // CreateKeywordSetRequest | 

try {
    final result = await api_instance.keywordSetsCreate(createKeywordSetRequest);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->keywordSetsCreate: $e\n');
}

import org.openapitools.client.api.KeywordSetsApi;

public class KeywordSetsApiExample {
    public static void main(String[] args) {
        KeywordSetsApi apiInstance = new KeywordSetsApi();
        CreateKeywordSetRequest createKeywordSetRequest = ; // CreateKeywordSetRequest | 

        try {
            keyword_sets_create_201_response result = apiInstance.keywordSetsCreate(createKeywordSetRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling KeywordSetsApi#keywordSetsCreate");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: cookieAuth)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"domainflow_session"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"domainflow_session"];


// Create an instance of the API class
KeywordSetsApi *apiInstance = [[KeywordSetsApi alloc] init];
CreateKeywordSetRequest *createKeywordSetRequest = ; // 

// Create keyword set
[apiInstance keywordSetsCreateWith:createKeywordSetRequest
              completionHandler: ^(keyword_sets_create_201_response output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var DomainFlowApi = require('domain_flow_api');
var defaultClient = DomainFlowApi.ApiClient.instance;

// Configure API key authorization: cookieAuth
var cookieAuth = defaultClient.authentications['cookieAuth'];
cookieAuth.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//cookieAuth.apiKeyPrefix['domainflow_session'] = "Token";

// Create an instance of the API class
var api = new DomainFlowApi.KeywordSetsApi()
var createKeywordSetRequest = ; // {CreateKeywordSetRequest} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.keywordSetsCreate(createKeywordSetRequest, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class keywordSetsCreateExample
    {
        public void main()
        {
            // Configure API key authorization: cookieAuth
            Configuration.Default.ApiKey.Add("domainflow_session", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("domainflow_session", "Bearer");

            // Create an instance of the API class
            var apiInstance = new KeywordSetsApi();
            var createKeywordSetRequest = new CreateKeywordSetRequest(); // CreateKeywordSetRequest | 

            try {
                // Create keyword set
                keyword_sets_create_201_response result = apiInstance.keywordSetsCreate(createKeywordSetRequest);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling KeywordSetsApi.keywordSetsCreate: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure API key authorization: cookieAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('domainflow_session', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('domainflow_session', 'Bearer');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\KeywordSetsApi();
$createKeywordSetRequest = ; // CreateKeywordSetRequest | 

try {
    $result = $api_instance->keywordSetsCreate($createKeywordSetRequest);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling KeywordSetsApi->keywordSetsCreate: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::KeywordSetsApi;

# Configure API key authorization: cookieAuth
$WWW::OPenAPIClient::Configuration::api_key->{'domainflow_session'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'domainflow_session'} = "Bearer";

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::KeywordSetsApi->new();
my $createKeywordSetRequest = WWW::OPenAPIClient::Object::CreateKeywordSetRequest->new(); # CreateKeywordSetRequest | 

eval {
    my $result = $api_instance->keywordSetsCreate(createKeywordSetRequest => $createKeywordSetRequest);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling KeywordSetsApi->keywordSetsCreate: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure API key authorization: cookieAuth
openapi_client.configuration.api_key['domainflow_session'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['domainflow_session'] = 'Bearer'

# Create an instance of the API class
api_instance = openapi_client.KeywordSetsApi()
createKeywordSetRequest =  # CreateKeywordSetRequest | 

try:
    # Create keyword set
    api_response = api_instance.keyword_sets_create(createKeywordSetRequest)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling KeywordSetsApi->keywordSetsCreate: %s\n" % e)
extern crate KeywordSetsApi;

pub fn main() {
    let createKeywordSetRequest = ; // CreateKeywordSetRequest

    let mut context = KeywordSetsApi::Context::default();
    let result = client.keywordSetsCreate(createKeywordSetRequest, &context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Body parameters
Name Description
createKeywordSetRequest *

Responses

Name Type Format Description
Retry-After Integer Seconds to wait before retrying


keywordSetsDelete

Delete keyword set


/keyword-sets/{setId}

Usage and SDK Samples

curl -X DELETE \
 \
 -H "Accept: application/json" \
 "https://api.domainflow.dev/api/v2/keyword-sets/{setId}"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.KeywordSetsApi;

import java.io.File;
import java.util.*;

public class KeywordSetsApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure API key authorization: cookieAuth
        ApiKeyAuth cookieAuth = (ApiKeyAuth) defaultClient.getAuthentication("cookieAuth");
        cookieAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //cookieAuth.setApiKeyPrefix("Token");

        // Create an instance of the API class
        KeywordSetsApi apiInstance = new KeywordSetsApi();
        UUID setId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 

        try {
            apiInstance.keywordSetsDelete(setId);
        } catch (ApiException e) {
            System.err.println("Exception when calling KeywordSetsApi#keywordSetsDelete");
            e.printStackTrace();
        }
    }
}
import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final UUID setId = new UUID(); // UUID | 

try {
    final result = await api_instance.keywordSetsDelete(setId);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->keywordSetsDelete: $e\n');
}

import org.openapitools.client.api.KeywordSetsApi;

public class KeywordSetsApiExample {
    public static void main(String[] args) {
        KeywordSetsApi apiInstance = new KeywordSetsApi();
        UUID setId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 

        try {
            apiInstance.keywordSetsDelete(setId);
        } catch (ApiException e) {
            System.err.println("Exception when calling KeywordSetsApi#keywordSetsDelete");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: cookieAuth)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"domainflow_session"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"domainflow_session"];


// Create an instance of the API class
KeywordSetsApi *apiInstance = [[KeywordSetsApi alloc] init];
UUID *setId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; //  (default to null)

// Delete keyword set
[apiInstance keywordSetsDeleteWith:setId
              completionHandler: ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var DomainFlowApi = require('domain_flow_api');
var defaultClient = DomainFlowApi.ApiClient.instance;

// Configure API key authorization: cookieAuth
var cookieAuth = defaultClient.authentications['cookieAuth'];
cookieAuth.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//cookieAuth.apiKeyPrefix['domainflow_session'] = "Token";

// Create an instance of the API class
var api = new DomainFlowApi.KeywordSetsApi()
var setId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // {UUID} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.keywordSetsDelete(setId, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class keywordSetsDeleteExample
    {
        public void main()
        {
            // Configure API key authorization: cookieAuth
            Configuration.Default.ApiKey.Add("domainflow_session", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("domainflow_session", "Bearer");

            // Create an instance of the API class
            var apiInstance = new KeywordSetsApi();
            var setId = 38400000-8cf0-11bd-b23e-10b96e4ef00d;  // UUID |  (default to null)

            try {
                // Delete keyword set
                apiInstance.keywordSetsDelete(setId);
            } catch (Exception e) {
                Debug.Print("Exception when calling KeywordSetsApi.keywordSetsDelete: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure API key authorization: cookieAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('domainflow_session', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('domainflow_session', 'Bearer');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\KeywordSetsApi();
$setId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 

try {
    $api_instance->keywordSetsDelete($setId);
} catch (Exception $e) {
    echo 'Exception when calling KeywordSetsApi->keywordSetsDelete: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::KeywordSetsApi;

# Configure API key authorization: cookieAuth
$WWW::OPenAPIClient::Configuration::api_key->{'domainflow_session'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'domainflow_session'} = "Bearer";

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::KeywordSetsApi->new();
my $setId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; # UUID | 

eval {
    $api_instance->keywordSetsDelete(setId => $setId);
};
if ($@) {
    warn "Exception when calling KeywordSetsApi->keywordSetsDelete: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure API key authorization: cookieAuth
openapi_client.configuration.api_key['domainflow_session'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['domainflow_session'] = 'Bearer'

# Create an instance of the API class
api_instance = openapi_client.KeywordSetsApi()
setId = 38400000-8cf0-11bd-b23e-10b96e4ef00d # UUID |  (default to null)

try:
    # Delete keyword set
    api_instance.keyword_sets_delete(setId)
except ApiException as e:
    print("Exception when calling KeywordSetsApi->keywordSetsDelete: %s\n" % e)
extern crate KeywordSetsApi;

pub fn main() {
    let setId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID

    let mut context = KeywordSetsApi::Context::default();
    let result = client.keywordSetsDelete(setId, &context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Path parameters
Name Description
setId*
UUID (uuid)
Required

Responses

Name Type Format Description
Retry-After Integer Seconds to wait before retrying


keywordSetsGet

Get keyword set


/keyword-sets/{setId}

Usage and SDK Samples

curl -X GET \
 \
 -H "Accept: application/json" \
 "https://api.domainflow.dev/api/v2/keyword-sets/{setId}"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.KeywordSetsApi;

import java.io.File;
import java.util.*;

public class KeywordSetsApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure API key authorization: cookieAuth
        ApiKeyAuth cookieAuth = (ApiKeyAuth) defaultClient.getAuthentication("cookieAuth");
        cookieAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //cookieAuth.setApiKeyPrefix("Token");

        // Create an instance of the API class
        KeywordSetsApi apiInstance = new KeywordSetsApi();
        UUID setId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 

        try {
            keyword_sets_create_201_response result = apiInstance.keywordSetsGet(setId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling KeywordSetsApi#keywordSetsGet");
            e.printStackTrace();
        }
    }
}
import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final UUID setId = new UUID(); // UUID | 

try {
    final result = await api_instance.keywordSetsGet(setId);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->keywordSetsGet: $e\n');
}

import org.openapitools.client.api.KeywordSetsApi;

public class KeywordSetsApiExample {
    public static void main(String[] args) {
        KeywordSetsApi apiInstance = new KeywordSetsApi();
        UUID setId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 

        try {
            keyword_sets_create_201_response result = apiInstance.keywordSetsGet(setId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling KeywordSetsApi#keywordSetsGet");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: cookieAuth)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"domainflow_session"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"domainflow_session"];


// Create an instance of the API class
KeywordSetsApi *apiInstance = [[KeywordSetsApi alloc] init];
UUID *setId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; //  (default to null)

// Get keyword set
[apiInstance keywordSetsGetWith:setId
              completionHandler: ^(keyword_sets_create_201_response output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var DomainFlowApi = require('domain_flow_api');
var defaultClient = DomainFlowApi.ApiClient.instance;

// Configure API key authorization: cookieAuth
var cookieAuth = defaultClient.authentications['cookieAuth'];
cookieAuth.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//cookieAuth.apiKeyPrefix['domainflow_session'] = "Token";

// Create an instance of the API class
var api = new DomainFlowApi.KeywordSetsApi()
var setId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // {UUID} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.keywordSetsGet(setId, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class keywordSetsGetExample
    {
        public void main()
        {
            // Configure API key authorization: cookieAuth
            Configuration.Default.ApiKey.Add("domainflow_session", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("domainflow_session", "Bearer");

            // Create an instance of the API class
            var apiInstance = new KeywordSetsApi();
            var setId = 38400000-8cf0-11bd-b23e-10b96e4ef00d;  // UUID |  (default to null)

            try {
                // Get keyword set
                keyword_sets_create_201_response result = apiInstance.keywordSetsGet(setId);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling KeywordSetsApi.keywordSetsGet: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure API key authorization: cookieAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('domainflow_session', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('domainflow_session', 'Bearer');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\KeywordSetsApi();
$setId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 

try {
    $result = $api_instance->keywordSetsGet($setId);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling KeywordSetsApi->keywordSetsGet: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::KeywordSetsApi;

# Configure API key authorization: cookieAuth
$WWW::OPenAPIClient::Configuration::api_key->{'domainflow_session'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'domainflow_session'} = "Bearer";

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::KeywordSetsApi->new();
my $setId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; # UUID | 

eval {
    my $result = $api_instance->keywordSetsGet(setId => $setId);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling KeywordSetsApi->keywordSetsGet: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure API key authorization: cookieAuth
openapi_client.configuration.api_key['domainflow_session'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['domainflow_session'] = 'Bearer'

# Create an instance of the API class
api_instance = openapi_client.KeywordSetsApi()
setId = 38400000-8cf0-11bd-b23e-10b96e4ef00d # UUID |  (default to null)

try:
    # Get keyword set
    api_response = api_instance.keyword_sets_get(setId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling KeywordSetsApi->keywordSetsGet: %s\n" % e)
extern crate KeywordSetsApi;

pub fn main() {
    let setId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID

    let mut context = KeywordSetsApi::Context::default();
    let result = client.keywordSetsGet(setId, &context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Path parameters
Name Description
setId*
UUID (uuid)
Required

Responses

Name Type Format Description
Retry-After Integer Seconds to wait before retrying


keywordSetsList

List keyword sets


/keyword-sets

Usage and SDK Samples

curl -X GET \
 \
 -H "Accept: application/json" \
 "https://api.domainflow.dev/api/v2/keyword-sets?limit=56&offset=56&includeRules=true&isEnabled=true"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.KeywordSetsApi;

import java.io.File;
import java.util.*;

public class KeywordSetsApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure API key authorization: cookieAuth
        ApiKeyAuth cookieAuth = (ApiKeyAuth) defaultClient.getAuthentication("cookieAuth");
        cookieAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //cookieAuth.setApiKeyPrefix("Token");

        // Create an instance of the API class
        KeywordSetsApi apiInstance = new KeywordSetsApi();
        Integer limit = 56; // Integer | Page size (items per page)
        Integer offset = 56; // Integer | Zero-based offset
        Boolean includeRules = true; // Boolean | If true, include rules array in keyword-sets list items
        Boolean isEnabled = true; // Boolean | Filter by enabled state

        try {
            keyword_sets_list_200_response result = apiInstance.keywordSetsList(limit, offset, includeRules, isEnabled);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling KeywordSetsApi#keywordSetsList");
            e.printStackTrace();
        }
    }
}
import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final Integer limit = new Integer(); // Integer | Page size (items per page)
final Integer offset = new Integer(); // Integer | Zero-based offset
final Boolean includeRules = new Boolean(); // Boolean | If true, include rules array in keyword-sets list items
final Boolean isEnabled = new Boolean(); // Boolean | Filter by enabled state

try {
    final result = await api_instance.keywordSetsList(limit, offset, includeRules, isEnabled);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->keywordSetsList: $e\n');
}

import org.openapitools.client.api.KeywordSetsApi;

public class KeywordSetsApiExample {
    public static void main(String[] args) {
        KeywordSetsApi apiInstance = new KeywordSetsApi();
        Integer limit = 56; // Integer | Page size (items per page)
        Integer offset = 56; // Integer | Zero-based offset
        Boolean includeRules = true; // Boolean | If true, include rules array in keyword-sets list items
        Boolean isEnabled = true; // Boolean | Filter by enabled state

        try {
            keyword_sets_list_200_response result = apiInstance.keywordSetsList(limit, offset, includeRules, isEnabled);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling KeywordSetsApi#keywordSetsList");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: cookieAuth)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"domainflow_session"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"domainflow_session"];


// Create an instance of the API class
KeywordSetsApi *apiInstance = [[KeywordSetsApi alloc] init];
Integer *limit = 56; // Page size (items per page) (optional) (default to 50)
Integer *offset = 56; // Zero-based offset (optional) (default to 0)
Boolean *includeRules = true; // If true, include rules array in keyword-sets list items (optional) (default to null)
Boolean *isEnabled = true; // Filter by enabled state (optional) (default to null)

// List keyword sets
[apiInstance keywordSetsListWith:limit
    offset:offset
    includeRules:includeRules
    isEnabled:isEnabled
              completionHandler: ^(keyword_sets_list_200_response output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var DomainFlowApi = require('domain_flow_api');
var defaultClient = DomainFlowApi.ApiClient.instance;

// Configure API key authorization: cookieAuth
var cookieAuth = defaultClient.authentications['cookieAuth'];
cookieAuth.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//cookieAuth.apiKeyPrefix['domainflow_session'] = "Token";

// Create an instance of the API class
var api = new DomainFlowApi.KeywordSetsApi()
var opts = {
  'limit': 56, // {Integer} Page size (items per page)
  'offset': 56, // {Integer} Zero-based offset
  'includeRules': true, // {Boolean} If true, include rules array in keyword-sets list items
  'isEnabled': true // {Boolean} Filter by enabled state
};

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.keywordSetsList(opts, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class keywordSetsListExample
    {
        public void main()
        {
            // Configure API key authorization: cookieAuth
            Configuration.Default.ApiKey.Add("domainflow_session", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("domainflow_session", "Bearer");

            // Create an instance of the API class
            var apiInstance = new KeywordSetsApi();
            var limit = 56;  // Integer | Page size (items per page) (optional)  (default to 50)
            var offset = 56;  // Integer | Zero-based offset (optional)  (default to 0)
            var includeRules = true;  // Boolean | If true, include rules array in keyword-sets list items (optional)  (default to null)
            var isEnabled = true;  // Boolean | Filter by enabled state (optional)  (default to null)

            try {
                // List keyword sets
                keyword_sets_list_200_response result = apiInstance.keywordSetsList(limit, offset, includeRules, isEnabled);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling KeywordSetsApi.keywordSetsList: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure API key authorization: cookieAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('domainflow_session', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('domainflow_session', 'Bearer');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\KeywordSetsApi();
$limit = 56; // Integer | Page size (items per page)
$offset = 56; // Integer | Zero-based offset
$includeRules = true; // Boolean | If true, include rules array in keyword-sets list items
$isEnabled = true; // Boolean | Filter by enabled state

try {
    $result = $api_instance->keywordSetsList($limit, $offset, $includeRules, $isEnabled);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling KeywordSetsApi->keywordSetsList: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::KeywordSetsApi;

# Configure API key authorization: cookieAuth
$WWW::OPenAPIClient::Configuration::api_key->{'domainflow_session'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'domainflow_session'} = "Bearer";

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::KeywordSetsApi->new();
my $limit = 56; # Integer | Page size (items per page)
my $offset = 56; # Integer | Zero-based offset
my $includeRules = true; # Boolean | If true, include rules array in keyword-sets list items
my $isEnabled = true; # Boolean | Filter by enabled state

eval {
    my $result = $api_instance->keywordSetsList(limit => $limit, offset => $offset, includeRules => $includeRules, isEnabled => $isEnabled);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling KeywordSetsApi->keywordSetsList: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure API key authorization: cookieAuth
openapi_client.configuration.api_key['domainflow_session'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['domainflow_session'] = 'Bearer'

# Create an instance of the API class
api_instance = openapi_client.KeywordSetsApi()
limit = 56 # Integer | Page size (items per page) (optional) (default to 50)
offset = 56 # Integer | Zero-based offset (optional) (default to 0)
includeRules = true # Boolean | If true, include rules array in keyword-sets list items (optional) (default to null)
isEnabled = true # Boolean | Filter by enabled state (optional) (default to null)

try:
    # List keyword sets
    api_response = api_instance.keyword_sets_list(limit=limit, offset=offset, includeRules=includeRules, isEnabled=isEnabled)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling KeywordSetsApi->keywordSetsList: %s\n" % e)
extern crate KeywordSetsApi;

pub fn main() {
    let limit = 56; // Integer
    let offset = 56; // Integer
    let includeRules = true; // Boolean
    let isEnabled = true; // Boolean

    let mut context = KeywordSetsApi::Context::default();
    let result = client.keywordSetsList(limit, offset, includeRules, isEnabled, &context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Query parameters
Name Description
limit
Integer
Page size (items per page)
offset
Integer
Zero-based offset
includeRules
Boolean
If true, include rules array in keyword-sets list items
isEnabled
Boolean
Filter by enabled state

Responses

Name Type Format Description
Retry-After Integer Seconds to wait before retrying


keywordSetsRulesList

List rules for a keyword set


/keyword-sets/{setId}/rules

Usage and SDK Samples

curl -X GET \
 \
 -H "Accept: application/json" \
 "https://api.domainflow.dev/api/v2/keyword-sets/{setId}/rules"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.KeywordSetsApi;

import java.io.File;
import java.util.*;

public class KeywordSetsApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure API key authorization: cookieAuth
        ApiKeyAuth cookieAuth = (ApiKeyAuth) defaultClient.getAuthentication("cookieAuth");
        cookieAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //cookieAuth.setApiKeyPrefix("Token");

        // Create an instance of the API class
        KeywordSetsApi apiInstance = new KeywordSetsApi();
        UUID setId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 

        try {
            keyword_sets_rules_list_200_response result = apiInstance.keywordSetsRulesList(setId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling KeywordSetsApi#keywordSetsRulesList");
            e.printStackTrace();
        }
    }
}
import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final UUID setId = new UUID(); // UUID | 

try {
    final result = await api_instance.keywordSetsRulesList(setId);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->keywordSetsRulesList: $e\n');
}

import org.openapitools.client.api.KeywordSetsApi;

public class KeywordSetsApiExample {
    public static void main(String[] args) {
        KeywordSetsApi apiInstance = new KeywordSetsApi();
        UUID setId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 

        try {
            keyword_sets_rules_list_200_response result = apiInstance.keywordSetsRulesList(setId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling KeywordSetsApi#keywordSetsRulesList");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: cookieAuth)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"domainflow_session"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"domainflow_session"];


// Create an instance of the API class
KeywordSetsApi *apiInstance = [[KeywordSetsApi alloc] init];
UUID *setId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; //  (default to null)

// List rules for a keyword set
[apiInstance keywordSetsRulesListWith:setId
              completionHandler: ^(keyword_sets_rules_list_200_response output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var DomainFlowApi = require('domain_flow_api');
var defaultClient = DomainFlowApi.ApiClient.instance;

// Configure API key authorization: cookieAuth
var cookieAuth = defaultClient.authentications['cookieAuth'];
cookieAuth.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//cookieAuth.apiKeyPrefix['domainflow_session'] = "Token";

// Create an instance of the API class
var api = new DomainFlowApi.KeywordSetsApi()
var setId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // {UUID} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.keywordSetsRulesList(setId, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class keywordSetsRulesListExample
    {
        public void main()
        {
            // Configure API key authorization: cookieAuth
            Configuration.Default.ApiKey.Add("domainflow_session", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("domainflow_session", "Bearer");

            // Create an instance of the API class
            var apiInstance = new KeywordSetsApi();
            var setId = 38400000-8cf0-11bd-b23e-10b96e4ef00d;  // UUID |  (default to null)

            try {
                // List rules for a keyword set
                keyword_sets_rules_list_200_response result = apiInstance.keywordSetsRulesList(setId);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling KeywordSetsApi.keywordSetsRulesList: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure API key authorization: cookieAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('domainflow_session', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('domainflow_session', 'Bearer');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\KeywordSetsApi();
$setId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 

try {
    $result = $api_instance->keywordSetsRulesList($setId);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling KeywordSetsApi->keywordSetsRulesList: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::KeywordSetsApi;

# Configure API key authorization: cookieAuth
$WWW::OPenAPIClient::Configuration::api_key->{'domainflow_session'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'domainflow_session'} = "Bearer";

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::KeywordSetsApi->new();
my $setId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; # UUID | 

eval {
    my $result = $api_instance->keywordSetsRulesList(setId => $setId);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling KeywordSetsApi->keywordSetsRulesList: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure API key authorization: cookieAuth
openapi_client.configuration.api_key['domainflow_session'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['domainflow_session'] = 'Bearer'

# Create an instance of the API class
api_instance = openapi_client.KeywordSetsApi()
setId = 38400000-8cf0-11bd-b23e-10b96e4ef00d # UUID |  (default to null)

try:
    # List rules for a keyword set
    api_response = api_instance.keyword_sets_rules_list(setId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling KeywordSetsApi->keywordSetsRulesList: %s\n" % e)
extern crate KeywordSetsApi;

pub fn main() {
    let setId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID

    let mut context = KeywordSetsApi::Context::default();
    let result = client.keywordSetsRulesList(setId, &context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Path parameters
Name Description
setId*
UUID (uuid)
Required

Responses

Name Type Format Description
Retry-After Integer Seconds to wait before retrying


keywordSetsUpdate

Update keyword set


/keyword-sets/{setId}

Usage and SDK Samples

curl -X PUT \
 \
 -H "Accept: application/json" \
 -H "Content-Type: application/json" \
 "https://api.domainflow.dev/api/v2/keyword-sets/{setId}" \
 -d '{
  "isEnabled" : true,
  "name" : "name",
  "description" : "description",
  "rules" : [ {
    "isCaseSensitive" : true,
    "ruleType" : "string",
    "pattern" : "pattern",
    "category" : "category",
    "contextChars" : 0
  }, {
    "isCaseSensitive" : true,
    "ruleType" : "string",
    "pattern" : "pattern",
    "category" : "category",
    "contextChars" : 0
  } ]
}'
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.KeywordSetsApi;

import java.io.File;
import java.util.*;

public class KeywordSetsApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure API key authorization: cookieAuth
        ApiKeyAuth cookieAuth = (ApiKeyAuth) defaultClient.getAuthentication("cookieAuth");
        cookieAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //cookieAuth.setApiKeyPrefix("Token");

        // Create an instance of the API class
        KeywordSetsApi apiInstance = new KeywordSetsApi();
        UUID setId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 
        UpdateKeywordSetRequest updateKeywordSetRequest = ; // UpdateKeywordSetRequest | 

        try {
            keyword_sets_create_201_response result = apiInstance.keywordSetsUpdate(setId, updateKeywordSetRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling KeywordSetsApi#keywordSetsUpdate");
            e.printStackTrace();
        }
    }
}
import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final UUID setId = new UUID(); // UUID | 
final UpdateKeywordSetRequest updateKeywordSetRequest = new UpdateKeywordSetRequest(); // UpdateKeywordSetRequest | 

try {
    final result = await api_instance.keywordSetsUpdate(setId, updateKeywordSetRequest);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->keywordSetsUpdate: $e\n');
}

import org.openapitools.client.api.KeywordSetsApi;

public class KeywordSetsApiExample {
    public static void main(String[] args) {
        KeywordSetsApi apiInstance = new KeywordSetsApi();
        UUID setId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 
        UpdateKeywordSetRequest updateKeywordSetRequest = ; // UpdateKeywordSetRequest | 

        try {
            keyword_sets_create_201_response result = apiInstance.keywordSetsUpdate(setId, updateKeywordSetRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling KeywordSetsApi#keywordSetsUpdate");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: cookieAuth)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"domainflow_session"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"domainflow_session"];


// Create an instance of the API class
KeywordSetsApi *apiInstance = [[KeywordSetsApi alloc] init];
UUID *setId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; //  (default to null)
UpdateKeywordSetRequest *updateKeywordSetRequest = ; // 

// Update keyword set
[apiInstance keywordSetsUpdateWith:setId
    updateKeywordSetRequest:updateKeywordSetRequest
              completionHandler: ^(keyword_sets_create_201_response output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var DomainFlowApi = require('domain_flow_api');
var defaultClient = DomainFlowApi.ApiClient.instance;

// Configure API key authorization: cookieAuth
var cookieAuth = defaultClient.authentications['cookieAuth'];
cookieAuth.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//cookieAuth.apiKeyPrefix['domainflow_session'] = "Token";

// Create an instance of the API class
var api = new DomainFlowApi.KeywordSetsApi()
var setId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // {UUID} 
var updateKeywordSetRequest = ; // {UpdateKeywordSetRequest} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.keywordSetsUpdate(setId, updateKeywordSetRequest, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class keywordSetsUpdateExample
    {
        public void main()
        {
            // Configure API key authorization: cookieAuth
            Configuration.Default.ApiKey.Add("domainflow_session", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("domainflow_session", "Bearer");

            // Create an instance of the API class
            var apiInstance = new KeywordSetsApi();
            var setId = 38400000-8cf0-11bd-b23e-10b96e4ef00d;  // UUID |  (default to null)
            var updateKeywordSetRequest = new UpdateKeywordSetRequest(); // UpdateKeywordSetRequest | 

            try {
                // Update keyword set
                keyword_sets_create_201_response result = apiInstance.keywordSetsUpdate(setId, updateKeywordSetRequest);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling KeywordSetsApi.keywordSetsUpdate: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure API key authorization: cookieAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('domainflow_session', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('domainflow_session', 'Bearer');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\KeywordSetsApi();
$setId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 
$updateKeywordSetRequest = ; // UpdateKeywordSetRequest | 

try {
    $result = $api_instance->keywordSetsUpdate($setId, $updateKeywordSetRequest);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling KeywordSetsApi->keywordSetsUpdate: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::KeywordSetsApi;

# Configure API key authorization: cookieAuth
$WWW::OPenAPIClient::Configuration::api_key->{'domainflow_session'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'domainflow_session'} = "Bearer";

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::KeywordSetsApi->new();
my $setId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; # UUID | 
my $updateKeywordSetRequest = WWW::OPenAPIClient::Object::UpdateKeywordSetRequest->new(); # UpdateKeywordSetRequest | 

eval {
    my $result = $api_instance->keywordSetsUpdate(setId => $setId, updateKeywordSetRequest => $updateKeywordSetRequest);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling KeywordSetsApi->keywordSetsUpdate: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure API key authorization: cookieAuth
openapi_client.configuration.api_key['domainflow_session'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['domainflow_session'] = 'Bearer'

# Create an instance of the API class
api_instance = openapi_client.KeywordSetsApi()
setId = 38400000-8cf0-11bd-b23e-10b96e4ef00d # UUID |  (default to null)
updateKeywordSetRequest =  # UpdateKeywordSetRequest | 

try:
    # Update keyword set
    api_response = api_instance.keyword_sets_update(setId, updateKeywordSetRequest)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling KeywordSetsApi->keywordSetsUpdate: %s\n" % e)
extern crate KeywordSetsApi;

pub fn main() {
    let setId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID
    let updateKeywordSetRequest = ; // UpdateKeywordSetRequest

    let mut context = KeywordSetsApi::Context::default();
    let result = client.keywordSetsUpdate(setId, updateKeywordSetRequest, &context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Path parameters
Name Description
setId*
UUID (uuid)
Required
Body parameters
Name Description
updateKeywordSetRequest *

Responses

Name Type Format Description
Retry-After Integer Seconds to wait before retrying


Monitoring

monitoringCampaignGeneric

Monitoring campaign-specific endpoint


/monitoring/cleanup/campaigns/{campaignId}

Usage and SDK Samples

curl -X GET \
 \
 -H "Accept: application/json" \
 "https://api.domainflow.dev/api/v2/monitoring/cleanup/campaigns/{campaignId}"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.MonitoringApi;

import java.io.File;
import java.util.*;

public class MonitoringApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure API key authorization: cookieAuth
        ApiKeyAuth cookieAuth = (ApiKeyAuth) defaultClient.getAuthentication("cookieAuth");
        cookieAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //cookieAuth.setApiKeyPrefix("Token");

        // Create an instance of the API class
        MonitoringApi apiInstance = new MonitoringApi();
        UUID campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 

        try {
            monitoring_performance_summary_200_response result = apiInstance.monitoringCampaignGeneric(campaignId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling MonitoringApi#monitoringCampaignGeneric");
            e.printStackTrace();
        }
    }
}
import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final UUID campaignId = new UUID(); // UUID | 

try {
    final result = await api_instance.monitoringCampaignGeneric(campaignId);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->monitoringCampaignGeneric: $e\n');
}

import org.openapitools.client.api.MonitoringApi;

public class MonitoringApiExample {
    public static void main(String[] args) {
        MonitoringApi apiInstance = new MonitoringApi();
        UUID campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 

        try {
            monitoring_performance_summary_200_response result = apiInstance.monitoringCampaignGeneric(campaignId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling MonitoringApi#monitoringCampaignGeneric");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: cookieAuth)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"domainflow_session"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"domainflow_session"];


// Create an instance of the API class
MonitoringApi *apiInstance = [[MonitoringApi alloc] init];
UUID *campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; //  (default to null)

// Monitoring campaign-specific endpoint
[apiInstance monitoringCampaignGenericWith:campaignId
              completionHandler: ^(monitoring_performance_summary_200_response output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var DomainFlowApi = require('domain_flow_api');
var defaultClient = DomainFlowApi.ApiClient.instance;

// Configure API key authorization: cookieAuth
var cookieAuth = defaultClient.authentications['cookieAuth'];
cookieAuth.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//cookieAuth.apiKeyPrefix['domainflow_session'] = "Token";

// Create an instance of the API class
var api = new DomainFlowApi.MonitoringApi()
var campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // {UUID} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.monitoringCampaignGeneric(campaignId, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class monitoringCampaignGenericExample
    {
        public void main()
        {
            // Configure API key authorization: cookieAuth
            Configuration.Default.ApiKey.Add("domainflow_session", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("domainflow_session", "Bearer");

            // Create an instance of the API class
            var apiInstance = new MonitoringApi();
            var campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d;  // UUID |  (default to null)

            try {
                // Monitoring campaign-specific endpoint
                monitoring_performance_summary_200_response result = apiInstance.monitoringCampaignGeneric(campaignId);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling MonitoringApi.monitoringCampaignGeneric: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure API key authorization: cookieAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('domainflow_session', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('domainflow_session', 'Bearer');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\MonitoringApi();
$campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 

try {
    $result = $api_instance->monitoringCampaignGeneric($campaignId);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling MonitoringApi->monitoringCampaignGeneric: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::MonitoringApi;

# Configure API key authorization: cookieAuth
$WWW::OPenAPIClient::Configuration::api_key->{'domainflow_session'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'domainflow_session'} = "Bearer";

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::MonitoringApi->new();
my $campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; # UUID | 

eval {
    my $result = $api_instance->monitoringCampaignGeneric(campaignId => $campaignId);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling MonitoringApi->monitoringCampaignGeneric: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure API key authorization: cookieAuth
openapi_client.configuration.api_key['domainflow_session'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['domainflow_session'] = 'Bearer'

# Create an instance of the API class
api_instance = openapi_client.MonitoringApi()
campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d # UUID |  (default to null)

try:
    # Monitoring campaign-specific endpoint
    api_response = api_instance.monitoring_campaign_generic(campaignId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling MonitoringApi->monitoringCampaignGeneric: %s\n" % e)
extern crate MonitoringApi;

pub fn main() {
    let campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID

    let mut context = MonitoringApi::Context::default();
    let result = client.monitoringCampaignGeneric(campaignId, &context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Path parameters
Name Description
campaignId*
UUID (uuid)
Required

Responses


monitoringCampaignHealth

Monitoring campaign health


/monitoring/campaigns/{campaignId}/health

Usage and SDK Samples

curl -X GET \
 \
 -H "Accept: application/json" \
 "https://api.domainflow.dev/api/v2/monitoring/campaigns/{campaignId}/health"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.MonitoringApi;

import java.io.File;
import java.util.*;

public class MonitoringApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure API key authorization: cookieAuth
        ApiKeyAuth cookieAuth = (ApiKeyAuth) defaultClient.getAuthentication("cookieAuth");
        cookieAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //cookieAuth.setApiKeyPrefix("Token");

        // Create an instance of the API class
        MonitoringApi apiInstance = new MonitoringApi();
        UUID campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 

        try {
            monitoring_performance_summary_200_response result = apiInstance.monitoringCampaignHealth(campaignId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling MonitoringApi#monitoringCampaignHealth");
            e.printStackTrace();
        }
    }
}
import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final UUID campaignId = new UUID(); // UUID | 

try {
    final result = await api_instance.monitoringCampaignHealth(campaignId);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->monitoringCampaignHealth: $e\n');
}

import org.openapitools.client.api.MonitoringApi;

public class MonitoringApiExample {
    public static void main(String[] args) {
        MonitoringApi apiInstance = new MonitoringApi();
        UUID campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 

        try {
            monitoring_performance_summary_200_response result = apiInstance.monitoringCampaignHealth(campaignId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling MonitoringApi#monitoringCampaignHealth");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: cookieAuth)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"domainflow_session"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"domainflow_session"];


// Create an instance of the API class
MonitoringApi *apiInstance = [[MonitoringApi alloc] init];
UUID *campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; //  (default to null)

// Monitoring campaign health
[apiInstance monitoringCampaignHealthWith:campaignId
              completionHandler: ^(monitoring_performance_summary_200_response output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var DomainFlowApi = require('domain_flow_api');
var defaultClient = DomainFlowApi.ApiClient.instance;

// Configure API key authorization: cookieAuth
var cookieAuth = defaultClient.authentications['cookieAuth'];
cookieAuth.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//cookieAuth.apiKeyPrefix['domainflow_session'] = "Token";

// Create an instance of the API class
var api = new DomainFlowApi.MonitoringApi()
var campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // {UUID} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.monitoringCampaignHealth(campaignId, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class monitoringCampaignHealthExample
    {
        public void main()
        {
            // Configure API key authorization: cookieAuth
            Configuration.Default.ApiKey.Add("domainflow_session", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("domainflow_session", "Bearer");

            // Create an instance of the API class
            var apiInstance = new MonitoringApi();
            var campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d;  // UUID |  (default to null)

            try {
                // Monitoring campaign health
                monitoring_performance_summary_200_response result = apiInstance.monitoringCampaignHealth(campaignId);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling MonitoringApi.monitoringCampaignHealth: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure API key authorization: cookieAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('domainflow_session', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('domainflow_session', 'Bearer');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\MonitoringApi();
$campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 

try {
    $result = $api_instance->monitoringCampaignHealth($campaignId);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling MonitoringApi->monitoringCampaignHealth: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::MonitoringApi;

# Configure API key authorization: cookieAuth
$WWW::OPenAPIClient::Configuration::api_key->{'domainflow_session'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'domainflow_session'} = "Bearer";

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::MonitoringApi->new();
my $campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; # UUID | 

eval {
    my $result = $api_instance->monitoringCampaignHealth(campaignId => $campaignId);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling MonitoringApi->monitoringCampaignHealth: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure API key authorization: cookieAuth
openapi_client.configuration.api_key['domainflow_session'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['domainflow_session'] = 'Bearer'

# Create an instance of the API class
api_instance = openapi_client.MonitoringApi()
campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d # UUID |  (default to null)

try:
    # Monitoring campaign health
    api_response = api_instance.monitoring_campaign_health(campaignId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling MonitoringApi->monitoringCampaignHealth: %s\n" % e)
extern crate MonitoringApi;

pub fn main() {
    let campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID

    let mut context = MonitoringApi::Context::default();
    let result = client.monitoringCampaignHealth(campaignId, &context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Path parameters
Name Description
campaignId*
UUID (uuid)
Required

Responses


monitoringCampaignLimits

Set campaign resource limits


/monitoring/campaigns/{campaignId}/limits

Usage and SDK Samples

curl -X POST \
 \
 -H "Accept: application/json" \
 -H "Content-Type: application/json" \
 "https://api.domainflow.dev/api/v2/monitoring/campaigns/{campaignId}/limits" \
 -d '{
  "maxMemoryMB" : 0,
  "maxConcurrentJobs" : 0,
  "maxDurationSeconds" : 0,
  "maxCPUPercent" : 14.65813,
  "rateLimitPerMinute" : 0,
  "maxDiskMB" : 0
}'
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.MonitoringApi;

import java.io.File;
import java.util.*;

public class MonitoringApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure API key authorization: cookieAuth
        ApiKeyAuth cookieAuth = (ApiKeyAuth) defaultClient.getAuthentication("cookieAuth");
        cookieAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //cookieAuth.setApiKeyPrefix("Token");

        // Create an instance of the API class
        MonitoringApi apiInstance = new MonitoringApi();
        UUID campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 
        MonitoringCampaignLimitsRequest monitoringCampaignLimitsRequest = ; // MonitoringCampaignLimitsRequest | 

        try {
            apiInstance.monitoringCampaignLimits(campaignId, monitoringCampaignLimitsRequest);
        } catch (ApiException e) {
            System.err.println("Exception when calling MonitoringApi#monitoringCampaignLimits");
            e.printStackTrace();
        }
    }
}
import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final UUID campaignId = new UUID(); // UUID | 
final MonitoringCampaignLimitsRequest monitoringCampaignLimitsRequest = new MonitoringCampaignLimitsRequest(); // MonitoringCampaignLimitsRequest | 

try {
    final result = await api_instance.monitoringCampaignLimits(campaignId, monitoringCampaignLimitsRequest);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->monitoringCampaignLimits: $e\n');
}

import org.openapitools.client.api.MonitoringApi;

public class MonitoringApiExample {
    public static void main(String[] args) {
        MonitoringApi apiInstance = new MonitoringApi();
        UUID campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 
        MonitoringCampaignLimitsRequest monitoringCampaignLimitsRequest = ; // MonitoringCampaignLimitsRequest | 

        try {
            apiInstance.monitoringCampaignLimits(campaignId, monitoringCampaignLimitsRequest);
        } catch (ApiException e) {
            System.err.println("Exception when calling MonitoringApi#monitoringCampaignLimits");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: cookieAuth)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"domainflow_session"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"domainflow_session"];


// Create an instance of the API class
MonitoringApi *apiInstance = [[MonitoringApi alloc] init];
UUID *campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; //  (default to null)
MonitoringCampaignLimitsRequest *monitoringCampaignLimitsRequest = ; // 

// Set campaign resource limits
[apiInstance monitoringCampaignLimitsWith:campaignId
    monitoringCampaignLimitsRequest:monitoringCampaignLimitsRequest
              completionHandler: ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var DomainFlowApi = require('domain_flow_api');
var defaultClient = DomainFlowApi.ApiClient.instance;

// Configure API key authorization: cookieAuth
var cookieAuth = defaultClient.authentications['cookieAuth'];
cookieAuth.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//cookieAuth.apiKeyPrefix['domainflow_session'] = "Token";

// Create an instance of the API class
var api = new DomainFlowApi.MonitoringApi()
var campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // {UUID} 
var monitoringCampaignLimitsRequest = ; // {MonitoringCampaignLimitsRequest} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.monitoringCampaignLimits(campaignId, monitoringCampaignLimitsRequest, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class monitoringCampaignLimitsExample
    {
        public void main()
        {
            // Configure API key authorization: cookieAuth
            Configuration.Default.ApiKey.Add("domainflow_session", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("domainflow_session", "Bearer");

            // Create an instance of the API class
            var apiInstance = new MonitoringApi();
            var campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d;  // UUID |  (default to null)
            var monitoringCampaignLimitsRequest = new MonitoringCampaignLimitsRequest(); // MonitoringCampaignLimitsRequest | 

            try {
                // Set campaign resource limits
                apiInstance.monitoringCampaignLimits(campaignId, monitoringCampaignLimitsRequest);
            } catch (Exception e) {
                Debug.Print("Exception when calling MonitoringApi.monitoringCampaignLimits: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure API key authorization: cookieAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('domainflow_session', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('domainflow_session', 'Bearer');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\MonitoringApi();
$campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 
$monitoringCampaignLimitsRequest = ; // MonitoringCampaignLimitsRequest | 

try {
    $api_instance->monitoringCampaignLimits($campaignId, $monitoringCampaignLimitsRequest);
} catch (Exception $e) {
    echo 'Exception when calling MonitoringApi->monitoringCampaignLimits: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::MonitoringApi;

# Configure API key authorization: cookieAuth
$WWW::OPenAPIClient::Configuration::api_key->{'domainflow_session'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'domainflow_session'} = "Bearer";

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::MonitoringApi->new();
my $campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; # UUID | 
my $monitoringCampaignLimitsRequest = WWW::OPenAPIClient::Object::MonitoringCampaignLimitsRequest->new(); # MonitoringCampaignLimitsRequest | 

eval {
    $api_instance->monitoringCampaignLimits(campaignId => $campaignId, monitoringCampaignLimitsRequest => $monitoringCampaignLimitsRequest);
};
if ($@) {
    warn "Exception when calling MonitoringApi->monitoringCampaignLimits: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure API key authorization: cookieAuth
openapi_client.configuration.api_key['domainflow_session'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['domainflow_session'] = 'Bearer'

# Create an instance of the API class
api_instance = openapi_client.MonitoringApi()
campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d # UUID |  (default to null)
monitoringCampaignLimitsRequest =  # MonitoringCampaignLimitsRequest | 

try:
    # Set campaign resource limits
    api_instance.monitoring_campaign_limits(campaignId, monitoringCampaignLimitsRequest)
except ApiException as e:
    print("Exception when calling MonitoringApi->monitoringCampaignLimits: %s\n" % e)
extern crate MonitoringApi;

pub fn main() {
    let campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID
    let monitoringCampaignLimitsRequest = ; // MonitoringCampaignLimitsRequest

    let mut context = MonitoringApi::Context::default();
    let result = client.monitoringCampaignLimits(campaignId, monitoringCampaignLimitsRequest, &context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Path parameters
Name Description
campaignId*
UUID (uuid)
Required
Body parameters
Name Description
monitoringCampaignLimitsRequest *

Responses


monitoringCampaignPerformance

Monitoring campaign performance


/monitoring/campaigns/{campaignId}/performance

Usage and SDK Samples

curl -X GET \
 \
 -H "Accept: application/json" \
 "https://api.domainflow.dev/api/v2/monitoring/campaigns/{campaignId}/performance"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.MonitoringApi;

import java.io.File;
import java.util.*;

public class MonitoringApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure API key authorization: cookieAuth
        ApiKeyAuth cookieAuth = (ApiKeyAuth) defaultClient.getAuthentication("cookieAuth");
        cookieAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //cookieAuth.setApiKeyPrefix("Token");

        // Create an instance of the API class
        MonitoringApi apiInstance = new MonitoringApi();
        UUID campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 

        try {
            monitoring_performance_summary_200_response result = apiInstance.monitoringCampaignPerformance(campaignId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling MonitoringApi#monitoringCampaignPerformance");
            e.printStackTrace();
        }
    }
}
import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final UUID campaignId = new UUID(); // UUID | 

try {
    final result = await api_instance.monitoringCampaignPerformance(campaignId);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->monitoringCampaignPerformance: $e\n');
}

import org.openapitools.client.api.MonitoringApi;

public class MonitoringApiExample {
    public static void main(String[] args) {
        MonitoringApi apiInstance = new MonitoringApi();
        UUID campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 

        try {
            monitoring_performance_summary_200_response result = apiInstance.monitoringCampaignPerformance(campaignId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling MonitoringApi#monitoringCampaignPerformance");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: cookieAuth)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"domainflow_session"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"domainflow_session"];


// Create an instance of the API class
MonitoringApi *apiInstance = [[MonitoringApi alloc] init];
UUID *campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; //  (default to null)

// Monitoring campaign performance
[apiInstance monitoringCampaignPerformanceWith:campaignId
              completionHandler: ^(monitoring_performance_summary_200_response output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var DomainFlowApi = require('domain_flow_api');
var defaultClient = DomainFlowApi.ApiClient.instance;

// Configure API key authorization: cookieAuth
var cookieAuth = defaultClient.authentications['cookieAuth'];
cookieAuth.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//cookieAuth.apiKeyPrefix['domainflow_session'] = "Token";

// Create an instance of the API class
var api = new DomainFlowApi.MonitoringApi()
var campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // {UUID} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.monitoringCampaignPerformance(campaignId, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class monitoringCampaignPerformanceExample
    {
        public void main()
        {
            // Configure API key authorization: cookieAuth
            Configuration.Default.ApiKey.Add("domainflow_session", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("domainflow_session", "Bearer");

            // Create an instance of the API class
            var apiInstance = new MonitoringApi();
            var campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d;  // UUID |  (default to null)

            try {
                // Monitoring campaign performance
                monitoring_performance_summary_200_response result = apiInstance.monitoringCampaignPerformance(campaignId);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling MonitoringApi.monitoringCampaignPerformance: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure API key authorization: cookieAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('domainflow_session', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('domainflow_session', 'Bearer');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\MonitoringApi();
$campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 

try {
    $result = $api_instance->monitoringCampaignPerformance($campaignId);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling MonitoringApi->monitoringCampaignPerformance: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::MonitoringApi;

# Configure API key authorization: cookieAuth
$WWW::OPenAPIClient::Configuration::api_key->{'domainflow_session'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'domainflow_session'} = "Bearer";

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::MonitoringApi->new();
my $campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; # UUID | 

eval {
    my $result = $api_instance->monitoringCampaignPerformance(campaignId => $campaignId);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling MonitoringApi->monitoringCampaignPerformance: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure API key authorization: cookieAuth
openapi_client.configuration.api_key['domainflow_session'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['domainflow_session'] = 'Bearer'

# Create an instance of the API class
api_instance = openapi_client.MonitoringApi()
campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d # UUID |  (default to null)

try:
    # Monitoring campaign performance
    api_response = api_instance.monitoring_campaign_performance(campaignId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling MonitoringApi->monitoringCampaignPerformance: %s\n" % e)
extern crate MonitoringApi;

pub fn main() {
    let campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID

    let mut context = MonitoringApi::Context::default();
    let result = client.monitoringCampaignPerformance(campaignId, &context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Path parameters
Name Description
campaignId*
UUID (uuid)
Required

Responses


monitoringCampaignResources

Monitoring campaign resources


/monitoring/campaigns/{campaignId}/resources

Usage and SDK Samples

curl -X GET \
 \
 -H "Accept: application/json" \
 "https://api.domainflow.dev/api/v2/monitoring/campaigns/{campaignId}/resources"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.MonitoringApi;

import java.io.File;
import java.util.*;

public class MonitoringApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure API key authorization: cookieAuth
        ApiKeyAuth cookieAuth = (ApiKeyAuth) defaultClient.getAuthentication("cookieAuth");
        cookieAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //cookieAuth.setApiKeyPrefix("Token");

        // Create an instance of the API class
        MonitoringApi apiInstance = new MonitoringApi();
        UUID campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 

        try {
            monitoring_performance_summary_200_response result = apiInstance.monitoringCampaignResources(campaignId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling MonitoringApi#monitoringCampaignResources");
            e.printStackTrace();
        }
    }
}
import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final UUID campaignId = new UUID(); // UUID | 

try {
    final result = await api_instance.monitoringCampaignResources(campaignId);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->monitoringCampaignResources: $e\n');
}

import org.openapitools.client.api.MonitoringApi;

public class MonitoringApiExample {
    public static void main(String[] args) {
        MonitoringApi apiInstance = new MonitoringApi();
        UUID campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 

        try {
            monitoring_performance_summary_200_response result = apiInstance.monitoringCampaignResources(campaignId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling MonitoringApi#monitoringCampaignResources");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: cookieAuth)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"domainflow_session"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"domainflow_session"];


// Create an instance of the API class
MonitoringApi *apiInstance = [[MonitoringApi alloc] init];
UUID *campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; //  (default to null)

// Monitoring campaign resources
[apiInstance monitoringCampaignResourcesWith:campaignId
              completionHandler: ^(monitoring_performance_summary_200_response output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var DomainFlowApi = require('domain_flow_api');
var defaultClient = DomainFlowApi.ApiClient.instance;

// Configure API key authorization: cookieAuth
var cookieAuth = defaultClient.authentications['cookieAuth'];
cookieAuth.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//cookieAuth.apiKeyPrefix['domainflow_session'] = "Token";

// Create an instance of the API class
var api = new DomainFlowApi.MonitoringApi()
var campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // {UUID} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.monitoringCampaignResources(campaignId, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class monitoringCampaignResourcesExample
    {
        public void main()
        {
            // Configure API key authorization: cookieAuth
            Configuration.Default.ApiKey.Add("domainflow_session", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("domainflow_session", "Bearer");

            // Create an instance of the API class
            var apiInstance = new MonitoringApi();
            var campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d;  // UUID |  (default to null)

            try {
                // Monitoring campaign resources
                monitoring_performance_summary_200_response result = apiInstance.monitoringCampaignResources(campaignId);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling MonitoringApi.monitoringCampaignResources: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure API key authorization: cookieAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('domainflow_session', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('domainflow_session', 'Bearer');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\MonitoringApi();
$campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 

try {
    $result = $api_instance->monitoringCampaignResources($campaignId);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling MonitoringApi->monitoringCampaignResources: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::MonitoringApi;

# Configure API key authorization: cookieAuth
$WWW::OPenAPIClient::Configuration::api_key->{'domainflow_session'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'domainflow_session'} = "Bearer";

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::MonitoringApi->new();
my $campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; # UUID | 

eval {
    my $result = $api_instance->monitoringCampaignResources(campaignId => $campaignId);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling MonitoringApi->monitoringCampaignResources: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure API key authorization: cookieAuth
openapi_client.configuration.api_key['domainflow_session'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['domainflow_session'] = 'Bearer'

# Create an instance of the API class
api_instance = openapi_client.MonitoringApi()
campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d # UUID |  (default to null)

try:
    # Monitoring campaign resources
    api_response = api_instance.monitoring_campaign_resources(campaignId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling MonitoringApi->monitoringCampaignResources: %s\n" % e)
extern crate MonitoringApi;

pub fn main() {
    let campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID

    let mut context = MonitoringApi::Context::default();
    let result = client.monitoringCampaignResources(campaignId, &context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Path parameters
Name Description
campaignId*
UUID (uuid)
Required

Responses


monitoringCleanupForce

Force cleanup


/monitoring/cleanup/campaigns/{campaignId}/force

Usage and SDK Samples

curl -X POST \
 \
 -H "Accept: application/json" \
 "https://api.domainflow.dev/api/v2/monitoring/cleanup/campaigns/{campaignId}/force"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.MonitoringApi;

import java.io.File;
import java.util.*;

public class MonitoringApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure API key authorization: cookieAuth
        ApiKeyAuth cookieAuth = (ApiKeyAuth) defaultClient.getAuthentication("cookieAuth");
        cookieAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //cookieAuth.setApiKeyPrefix("Token");

        // Create an instance of the API class
        MonitoringApi apiInstance = new MonitoringApi();
        UUID campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 

        try {
            apiInstance.monitoringCleanupForce(campaignId);
        } catch (ApiException e) {
            System.err.println("Exception when calling MonitoringApi#monitoringCleanupForce");
            e.printStackTrace();
        }
    }
}
import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final UUID campaignId = new UUID(); // UUID | 

try {
    final result = await api_instance.monitoringCleanupForce(campaignId);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->monitoringCleanupForce: $e\n');
}

import org.openapitools.client.api.MonitoringApi;

public class MonitoringApiExample {
    public static void main(String[] args) {
        MonitoringApi apiInstance = new MonitoringApi();
        UUID campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 

        try {
            apiInstance.monitoringCleanupForce(campaignId);
        } catch (ApiException e) {
            System.err.println("Exception when calling MonitoringApi#monitoringCleanupForce");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: cookieAuth)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"domainflow_session"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"domainflow_session"];


// Create an instance of the API class
MonitoringApi *apiInstance = [[MonitoringApi alloc] init];
UUID *campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; //  (default to null)

// Force cleanup
[apiInstance monitoringCleanupForceWith:campaignId
              completionHandler: ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var DomainFlowApi = require('domain_flow_api');
var defaultClient = DomainFlowApi.ApiClient.instance;

// Configure API key authorization: cookieAuth
var cookieAuth = defaultClient.authentications['cookieAuth'];
cookieAuth.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//cookieAuth.apiKeyPrefix['domainflow_session'] = "Token";

// Create an instance of the API class
var api = new DomainFlowApi.MonitoringApi()
var campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // {UUID} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.monitoringCleanupForce(campaignId, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class monitoringCleanupForceExample
    {
        public void main()
        {
            // Configure API key authorization: cookieAuth
            Configuration.Default.ApiKey.Add("domainflow_session", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("domainflow_session", "Bearer");

            // Create an instance of the API class
            var apiInstance = new MonitoringApi();
            var campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d;  // UUID |  (default to null)

            try {
                // Force cleanup
                apiInstance.monitoringCleanupForce(campaignId);
            } catch (Exception e) {
                Debug.Print("Exception when calling MonitoringApi.monitoringCleanupForce: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure API key authorization: cookieAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('domainflow_session', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('domainflow_session', 'Bearer');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\MonitoringApi();
$campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 

try {
    $api_instance->monitoringCleanupForce($campaignId);
} catch (Exception $e) {
    echo 'Exception when calling MonitoringApi->monitoringCleanupForce: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::MonitoringApi;

# Configure API key authorization: cookieAuth
$WWW::OPenAPIClient::Configuration::api_key->{'domainflow_session'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'domainflow_session'} = "Bearer";

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::MonitoringApi->new();
my $campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; # UUID | 

eval {
    $api_instance->monitoringCleanupForce(campaignId => $campaignId);
};
if ($@) {
    warn "Exception when calling MonitoringApi->monitoringCleanupForce: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure API key authorization: cookieAuth
openapi_client.configuration.api_key['domainflow_session'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['domainflow_session'] = 'Bearer'

# Create an instance of the API class
api_instance = openapi_client.MonitoringApi()
campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d # UUID |  (default to null)

try:
    # Force cleanup
    api_instance.monitoring_cleanup_force(campaignId)
except ApiException as e:
    print("Exception when calling MonitoringApi->monitoringCleanupForce: %s\n" % e)
extern crate MonitoringApi;

pub fn main() {
    let campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID

    let mut context = MonitoringApi::Context::default();
    let result = client.monitoringCleanupForce(campaignId, &context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Path parameters
Name Description
campaignId*
UUID (uuid)
Required

Responses


monitoringCleanupStats

Cleanup stats


/monitoring/cleanup/stats

Usage and SDK Samples

curl -X GET \
 \
 -H "Accept: application/json" \
 "https://api.domainflow.dev/api/v2/monitoring/cleanup/stats"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.MonitoringApi;

import java.io.File;
import java.util.*;

public class MonitoringApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure API key authorization: cookieAuth
        ApiKeyAuth cookieAuth = (ApiKeyAuth) defaultClient.getAuthentication("cookieAuth");
        cookieAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //cookieAuth.setApiKeyPrefix("Token");

        // Create an instance of the API class
        MonitoringApi apiInstance = new MonitoringApi();

        try {
            monitoring_performance_summary_200_response result = apiInstance.monitoringCleanupStats();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling MonitoringApi#monitoringCleanupStats");
            e.printStackTrace();
        }
    }
}
import 'package:openapi/api.dart';

final api_instance = DefaultApi();


try {
    final result = await api_instance.monitoringCleanupStats();
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->monitoringCleanupStats: $e\n');
}

import org.openapitools.client.api.MonitoringApi;

public class MonitoringApiExample {
    public static void main(String[] args) {
        MonitoringApi apiInstance = new MonitoringApi();

        try {
            monitoring_performance_summary_200_response result = apiInstance.monitoringCleanupStats();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling MonitoringApi#monitoringCleanupStats");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: cookieAuth)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"domainflow_session"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"domainflow_session"];


// Create an instance of the API class
MonitoringApi *apiInstance = [[MonitoringApi alloc] init];

// Cleanup stats
[apiInstance monitoringCleanupStatsWithCompletionHandler: 
              ^(monitoring_performance_summary_200_response output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var DomainFlowApi = require('domain_flow_api');
var defaultClient = DomainFlowApi.ApiClient.instance;

// Configure API key authorization: cookieAuth
var cookieAuth = defaultClient.authentications['cookieAuth'];
cookieAuth.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//cookieAuth.apiKeyPrefix['domainflow_session'] = "Token";

// Create an instance of the API class
var api = new DomainFlowApi.MonitoringApi()
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.monitoringCleanupStats(callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class monitoringCleanupStatsExample
    {
        public void main()
        {
            // Configure API key authorization: cookieAuth
            Configuration.Default.ApiKey.Add("domainflow_session", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("domainflow_session", "Bearer");

            // Create an instance of the API class
            var apiInstance = new MonitoringApi();

            try {
                // Cleanup stats
                monitoring_performance_summary_200_response result = apiInstance.monitoringCleanupStats();
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling MonitoringApi.monitoringCleanupStats: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure API key authorization: cookieAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('domainflow_session', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('domainflow_session', 'Bearer');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\MonitoringApi();

try {
    $result = $api_instance->monitoringCleanupStats();
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling MonitoringApi->monitoringCleanupStats: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::MonitoringApi;

# Configure API key authorization: cookieAuth
$WWW::OPenAPIClient::Configuration::api_key->{'domainflow_session'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'domainflow_session'} = "Bearer";

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::MonitoringApi->new();

eval {
    my $result = $api_instance->monitoringCleanupStats();
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling MonitoringApi->monitoringCleanupStats: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure API key authorization: cookieAuth
openapi_client.configuration.api_key['domainflow_session'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['domainflow_session'] = 'Bearer'

# Create an instance of the API class
api_instance = openapi_client.MonitoringApi()

try:
    # Cleanup stats
    api_response = api_instance.monitoring_cleanup_stats()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling MonitoringApi->monitoringCleanupStats: %s\n" % e)
extern crate MonitoringApi;

pub fn main() {

    let mut context = MonitoringApi::Context::default();
    let result = client.monitoringCleanupStats(&context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Responses


monitoringDashboardSummary

Monitoring dashboard summary


/monitoring/dashboard/summary

Usage and SDK Samples

curl -X GET \
 \
 -H "Accept: application/json" \
 "https://api.domainflow.dev/api/v2/monitoring/dashboard/summary"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.MonitoringApi;

import java.io.File;
import java.util.*;

public class MonitoringApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure API key authorization: cookieAuth
        ApiKeyAuth cookieAuth = (ApiKeyAuth) defaultClient.getAuthentication("cookieAuth");
        cookieAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //cookieAuth.setApiKeyPrefix("Token");

        // Create an instance of the API class
        MonitoringApi apiInstance = new MonitoringApi();

        try {
            monitoring_performance_summary_200_response result = apiInstance.monitoringDashboardSummary();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling MonitoringApi#monitoringDashboardSummary");
            e.printStackTrace();
        }
    }
}
import 'package:openapi/api.dart';

final api_instance = DefaultApi();


try {
    final result = await api_instance.monitoringDashboardSummary();
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->monitoringDashboardSummary: $e\n');
}

import org.openapitools.client.api.MonitoringApi;

public class MonitoringApiExample {
    public static void main(String[] args) {
        MonitoringApi apiInstance = new MonitoringApi();

        try {
            monitoring_performance_summary_200_response result = apiInstance.monitoringDashboardSummary();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling MonitoringApi#monitoringDashboardSummary");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: cookieAuth)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"domainflow_session"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"domainflow_session"];


// Create an instance of the API class
MonitoringApi *apiInstance = [[MonitoringApi alloc] init];

// Monitoring dashboard summary
[apiInstance monitoringDashboardSummaryWithCompletionHandler: 
              ^(monitoring_performance_summary_200_response output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var DomainFlowApi = require('domain_flow_api');
var defaultClient = DomainFlowApi.ApiClient.instance;

// Configure API key authorization: cookieAuth
var cookieAuth = defaultClient.authentications['cookieAuth'];
cookieAuth.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//cookieAuth.apiKeyPrefix['domainflow_session'] = "Token";

// Create an instance of the API class
var api = new DomainFlowApi.MonitoringApi()
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.monitoringDashboardSummary(callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class monitoringDashboardSummaryExample
    {
        public void main()
        {
            // Configure API key authorization: cookieAuth
            Configuration.Default.ApiKey.Add("domainflow_session", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("domainflow_session", "Bearer");

            // Create an instance of the API class
            var apiInstance = new MonitoringApi();

            try {
                // Monitoring dashboard summary
                monitoring_performance_summary_200_response result = apiInstance.monitoringDashboardSummary();
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling MonitoringApi.monitoringDashboardSummary: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure API key authorization: cookieAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('domainflow_session', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('domainflow_session', 'Bearer');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\MonitoringApi();

try {
    $result = $api_instance->monitoringDashboardSummary();
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling MonitoringApi->monitoringDashboardSummary: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::MonitoringApi;

# Configure API key authorization: cookieAuth
$WWW::OPenAPIClient::Configuration::api_key->{'domainflow_session'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'domainflow_session'} = "Bearer";

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::MonitoringApi->new();

eval {
    my $result = $api_instance->monitoringDashboardSummary();
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling MonitoringApi->monitoringDashboardSummary: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure API key authorization: cookieAuth
openapi_client.configuration.api_key['domainflow_session'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['domainflow_session'] = 'Bearer'

# Create an instance of the API class
api_instance = openapi_client.MonitoringApi()

try:
    # Monitoring dashboard summary
    api_response = api_instance.monitoring_dashboard_summary()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling MonitoringApi->monitoringDashboardSummary: %s\n" % e)
extern crate MonitoringApi;

pub fn main() {

    let mut context = MonitoringApi::Context::default();
    let result = client.monitoringDashboardSummary(&context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Responses


monitoringHealth

Monitoring health


/monitoring/health

Usage and SDK Samples

curl -X GET \
 \
 -H "Accept: application/json" \
 "https://api.domainflow.dev/api/v2/monitoring/health"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.MonitoringApi;

import java.io.File;
import java.util.*;

public class MonitoringApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure API key authorization: cookieAuth
        ApiKeyAuth cookieAuth = (ApiKeyAuth) defaultClient.getAuthentication("cookieAuth");
        cookieAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //cookieAuth.setApiKeyPrefix("Token");

        // Create an instance of the API class
        MonitoringApi apiInstance = new MonitoringApi();

        try {
            monitoring_performance_summary_200_response result = apiInstance.monitoringHealth();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling MonitoringApi#monitoringHealth");
            e.printStackTrace();
        }
    }
}
import 'package:openapi/api.dart';

final api_instance = DefaultApi();


try {
    final result = await api_instance.monitoringHealth();
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->monitoringHealth: $e\n');
}

import org.openapitools.client.api.MonitoringApi;

public class MonitoringApiExample {
    public static void main(String[] args) {
        MonitoringApi apiInstance = new MonitoringApi();

        try {
            monitoring_performance_summary_200_response result = apiInstance.monitoringHealth();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling MonitoringApi#monitoringHealth");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: cookieAuth)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"domainflow_session"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"domainflow_session"];


// Create an instance of the API class
MonitoringApi *apiInstance = [[MonitoringApi alloc] init];

// Monitoring health
[apiInstance monitoringHealthWithCompletionHandler: 
              ^(monitoring_performance_summary_200_response output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var DomainFlowApi = require('domain_flow_api');
var defaultClient = DomainFlowApi.ApiClient.instance;

// Configure API key authorization: cookieAuth
var cookieAuth = defaultClient.authentications['cookieAuth'];
cookieAuth.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//cookieAuth.apiKeyPrefix['domainflow_session'] = "Token";

// Create an instance of the API class
var api = new DomainFlowApi.MonitoringApi()
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.monitoringHealth(callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class monitoringHealthExample
    {
        public void main()
        {
            // Configure API key authorization: cookieAuth
            Configuration.Default.ApiKey.Add("domainflow_session", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("domainflow_session", "Bearer");

            // Create an instance of the API class
            var apiInstance = new MonitoringApi();

            try {
                // Monitoring health
                monitoring_performance_summary_200_response result = apiInstance.monitoringHealth();
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling MonitoringApi.monitoringHealth: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure API key authorization: cookieAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('domainflow_session', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('domainflow_session', 'Bearer');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\MonitoringApi();

try {
    $result = $api_instance->monitoringHealth();
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling MonitoringApi->monitoringHealth: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::MonitoringApi;

# Configure API key authorization: cookieAuth
$WWW::OPenAPIClient::Configuration::api_key->{'domainflow_session'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'domainflow_session'} = "Bearer";

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::MonitoringApi->new();

eval {
    my $result = $api_instance->monitoringHealth();
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling MonitoringApi->monitoringHealth: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure API key authorization: cookieAuth
openapi_client.configuration.api_key['domainflow_session'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['domainflow_session'] = 'Bearer'

# Create an instance of the API class
api_instance = openapi_client.MonitoringApi()

try:
    # Monitoring health
    api_response = api_instance.monitoring_health()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling MonitoringApi->monitoringHealth: %s\n" % e)
extern crate MonitoringApi;

pub fn main() {

    let mut context = MonitoringApi::Context::default();
    let result = client.monitoringHealth(&context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Responses


monitoringPerformanceActive

Monitoring performance active


/monitoring/performance/active

Usage and SDK Samples

curl -X GET \
 \
 -H "Accept: application/json" \
 "https://api.domainflow.dev/api/v2/monitoring/performance/active"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.MonitoringApi;

import java.io.File;
import java.util.*;

public class MonitoringApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure API key authorization: cookieAuth
        ApiKeyAuth cookieAuth = (ApiKeyAuth) defaultClient.getAuthentication("cookieAuth");
        cookieAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //cookieAuth.setApiKeyPrefix("Token");

        // Create an instance of the API class
        MonitoringApi apiInstance = new MonitoringApi();

        try {
            monitoring_performance_summary_200_response result = apiInstance.monitoringPerformanceActive();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling MonitoringApi#monitoringPerformanceActive");
            e.printStackTrace();
        }
    }
}
import 'package:openapi/api.dart';

final api_instance = DefaultApi();


try {
    final result = await api_instance.monitoringPerformanceActive();
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->monitoringPerformanceActive: $e\n');
}

import org.openapitools.client.api.MonitoringApi;

public class MonitoringApiExample {
    public static void main(String[] args) {
        MonitoringApi apiInstance = new MonitoringApi();

        try {
            monitoring_performance_summary_200_response result = apiInstance.monitoringPerformanceActive();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling MonitoringApi#monitoringPerformanceActive");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: cookieAuth)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"domainflow_session"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"domainflow_session"];


// Create an instance of the API class
MonitoringApi *apiInstance = [[MonitoringApi alloc] init];

// Monitoring performance active
[apiInstance monitoringPerformanceActiveWithCompletionHandler: 
              ^(monitoring_performance_summary_200_response output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var DomainFlowApi = require('domain_flow_api');
var defaultClient = DomainFlowApi.ApiClient.instance;

// Configure API key authorization: cookieAuth
var cookieAuth = defaultClient.authentications['cookieAuth'];
cookieAuth.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//cookieAuth.apiKeyPrefix['domainflow_session'] = "Token";

// Create an instance of the API class
var api = new DomainFlowApi.MonitoringApi()
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.monitoringPerformanceActive(callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class monitoringPerformanceActiveExample
    {
        public void main()
        {
            // Configure API key authorization: cookieAuth
            Configuration.Default.ApiKey.Add("domainflow_session", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("domainflow_session", "Bearer");

            // Create an instance of the API class
            var apiInstance = new MonitoringApi();

            try {
                // Monitoring performance active
                monitoring_performance_summary_200_response result = apiInstance.monitoringPerformanceActive();
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling MonitoringApi.monitoringPerformanceActive: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure API key authorization: cookieAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('domainflow_session', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('domainflow_session', 'Bearer');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\MonitoringApi();

try {
    $result = $api_instance->monitoringPerformanceActive();
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling MonitoringApi->monitoringPerformanceActive: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::MonitoringApi;

# Configure API key authorization: cookieAuth
$WWW::OPenAPIClient::Configuration::api_key->{'domainflow_session'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'domainflow_session'} = "Bearer";

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::MonitoringApi->new();

eval {
    my $result = $api_instance->monitoringPerformanceActive();
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling MonitoringApi->monitoringPerformanceActive: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure API key authorization: cookieAuth
openapi_client.configuration.api_key['domainflow_session'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['domainflow_session'] = 'Bearer'

# Create an instance of the API class
api_instance = openapi_client.MonitoringApi()

try:
    # Monitoring performance active
    api_response = api_instance.monitoring_performance_active()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling MonitoringApi->monitoringPerformanceActive: %s\n" % e)
extern crate MonitoringApi;

pub fn main() {

    let mut context = MonitoringApi::Context::default();
    let result = client.monitoringPerformanceActive(&context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Responses


monitoringPerformanceFailed

Monitoring performance failed


/monitoring/performance/failed

Usage and SDK Samples

curl -X GET \
 \
 -H "Accept: application/json" \
 "https://api.domainflow.dev/api/v2/monitoring/performance/failed"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.MonitoringApi;

import java.io.File;
import java.util.*;

public class MonitoringApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure API key authorization: cookieAuth
        ApiKeyAuth cookieAuth = (ApiKeyAuth) defaultClient.getAuthentication("cookieAuth");
        cookieAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //cookieAuth.setApiKeyPrefix("Token");

        // Create an instance of the API class
        MonitoringApi apiInstance = new MonitoringApi();

        try {
            monitoring_performance_summary_200_response result = apiInstance.monitoringPerformanceFailed();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling MonitoringApi#monitoringPerformanceFailed");
            e.printStackTrace();
        }
    }
}
import 'package:openapi/api.dart';

final api_instance = DefaultApi();


try {
    final result = await api_instance.monitoringPerformanceFailed();
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->monitoringPerformanceFailed: $e\n');
}

import org.openapitools.client.api.MonitoringApi;

public class MonitoringApiExample {
    public static void main(String[] args) {
        MonitoringApi apiInstance = new MonitoringApi();

        try {
            monitoring_performance_summary_200_response result = apiInstance.monitoringPerformanceFailed();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling MonitoringApi#monitoringPerformanceFailed");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: cookieAuth)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"domainflow_session"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"domainflow_session"];


// Create an instance of the API class
MonitoringApi *apiInstance = [[MonitoringApi alloc] init];

// Monitoring performance failed
[apiInstance monitoringPerformanceFailedWithCompletionHandler: 
              ^(monitoring_performance_summary_200_response output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var DomainFlowApi = require('domain_flow_api');
var defaultClient = DomainFlowApi.ApiClient.instance;

// Configure API key authorization: cookieAuth
var cookieAuth = defaultClient.authentications['cookieAuth'];
cookieAuth.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//cookieAuth.apiKeyPrefix['domainflow_session'] = "Token";

// Create an instance of the API class
var api = new DomainFlowApi.MonitoringApi()
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.monitoringPerformanceFailed(callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class monitoringPerformanceFailedExample
    {
        public void main()
        {
            // Configure API key authorization: cookieAuth
            Configuration.Default.ApiKey.Add("domainflow_session", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("domainflow_session", "Bearer");

            // Create an instance of the API class
            var apiInstance = new MonitoringApi();

            try {
                // Monitoring performance failed
                monitoring_performance_summary_200_response result = apiInstance.monitoringPerformanceFailed();
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling MonitoringApi.monitoringPerformanceFailed: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure API key authorization: cookieAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('domainflow_session', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('domainflow_session', 'Bearer');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\MonitoringApi();

try {
    $result = $api_instance->monitoringPerformanceFailed();
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling MonitoringApi->monitoringPerformanceFailed: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::MonitoringApi;

# Configure API key authorization: cookieAuth
$WWW::OPenAPIClient::Configuration::api_key->{'domainflow_session'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'domainflow_session'} = "Bearer";

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::MonitoringApi->new();

eval {
    my $result = $api_instance->monitoringPerformanceFailed();
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling MonitoringApi->monitoringPerformanceFailed: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure API key authorization: cookieAuth
openapi_client.configuration.api_key['domainflow_session'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['domainflow_session'] = 'Bearer'

# Create an instance of the API class
api_instance = openapi_client.MonitoringApi()

try:
    # Monitoring performance failed
    api_response = api_instance.monitoring_performance_failed()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling MonitoringApi->monitoringPerformanceFailed: %s\n" % e)
extern crate MonitoringApi;

pub fn main() {

    let mut context = MonitoringApi::Context::default();
    let result = client.monitoringPerformanceFailed(&context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Responses


monitoringPerformanceMetrics

Monitoring performance metrics


/monitoring/performance/metrics

Usage and SDK Samples

curl -X GET \
 \
 -H "Accept: application/json" \
 "https://api.domainflow.dev/api/v2/monitoring/performance/metrics"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.MonitoringApi;

import java.io.File;
import java.util.*;

public class MonitoringApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure API key authorization: cookieAuth
        ApiKeyAuth cookieAuth = (ApiKeyAuth) defaultClient.getAuthentication("cookieAuth");
        cookieAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //cookieAuth.setApiKeyPrefix("Token");

        // Create an instance of the API class
        MonitoringApi apiInstance = new MonitoringApi();

        try {
            monitoring_performance_summary_200_response result = apiInstance.monitoringPerformanceMetrics();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling MonitoringApi#monitoringPerformanceMetrics");
            e.printStackTrace();
        }
    }
}
import 'package:openapi/api.dart';

final api_instance = DefaultApi();


try {
    final result = await api_instance.monitoringPerformanceMetrics();
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->monitoringPerformanceMetrics: $e\n');
}

import org.openapitools.client.api.MonitoringApi;

public class MonitoringApiExample {
    public static void main(String[] args) {
        MonitoringApi apiInstance = new MonitoringApi();

        try {
            monitoring_performance_summary_200_response result = apiInstance.monitoringPerformanceMetrics();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling MonitoringApi#monitoringPerformanceMetrics");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: cookieAuth)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"domainflow_session"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"domainflow_session"];


// Create an instance of the API class
MonitoringApi *apiInstance = [[MonitoringApi alloc] init];

// Monitoring performance metrics
[apiInstance monitoringPerformanceMetricsWithCompletionHandler: 
              ^(monitoring_performance_summary_200_response output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var DomainFlowApi = require('domain_flow_api');
var defaultClient = DomainFlowApi.ApiClient.instance;

// Configure API key authorization: cookieAuth
var cookieAuth = defaultClient.authentications['cookieAuth'];
cookieAuth.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//cookieAuth.apiKeyPrefix['domainflow_session'] = "Token";

// Create an instance of the API class
var api = new DomainFlowApi.MonitoringApi()
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.monitoringPerformanceMetrics(callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class monitoringPerformanceMetricsExample
    {
        public void main()
        {
            // Configure API key authorization: cookieAuth
            Configuration.Default.ApiKey.Add("domainflow_session", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("domainflow_session", "Bearer");

            // Create an instance of the API class
            var apiInstance = new MonitoringApi();

            try {
                // Monitoring performance metrics
                monitoring_performance_summary_200_response result = apiInstance.monitoringPerformanceMetrics();
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling MonitoringApi.monitoringPerformanceMetrics: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure API key authorization: cookieAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('domainflow_session', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('domainflow_session', 'Bearer');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\MonitoringApi();

try {
    $result = $api_instance->monitoringPerformanceMetrics();
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling MonitoringApi->monitoringPerformanceMetrics: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::MonitoringApi;

# Configure API key authorization: cookieAuth
$WWW::OPenAPIClient::Configuration::api_key->{'domainflow_session'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'domainflow_session'} = "Bearer";

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::MonitoringApi->new();

eval {
    my $result = $api_instance->monitoringPerformanceMetrics();
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling MonitoringApi->monitoringPerformanceMetrics: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure API key authorization: cookieAuth
openapi_client.configuration.api_key['domainflow_session'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['domainflow_session'] = 'Bearer'

# Create an instance of the API class
api_instance = openapi_client.MonitoringApi()

try:
    # Monitoring performance metrics
    api_response = api_instance.monitoring_performance_metrics()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling MonitoringApi->monitoringPerformanceMetrics: %s\n" % e)
extern crate MonitoringApi;

pub fn main() {

    let mut context = MonitoringApi::Context::default();
    let result = client.monitoringPerformanceMetrics(&context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Responses


monitoringPerformanceSlow

Monitoring performance slow


/monitoring/performance/slow

Usage and SDK Samples

curl -X GET \
 \
 -H "Accept: application/json" \
 "https://api.domainflow.dev/api/v2/monitoring/performance/slow"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.MonitoringApi;

import java.io.File;
import java.util.*;

public class MonitoringApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure API key authorization: cookieAuth
        ApiKeyAuth cookieAuth = (ApiKeyAuth) defaultClient.getAuthentication("cookieAuth");
        cookieAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //cookieAuth.setApiKeyPrefix("Token");

        // Create an instance of the API class
        MonitoringApi apiInstance = new MonitoringApi();

        try {
            monitoring_performance_summary_200_response result = apiInstance.monitoringPerformanceSlow();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling MonitoringApi#monitoringPerformanceSlow");
            e.printStackTrace();
        }
    }
}
import 'package:openapi/api.dart';

final api_instance = DefaultApi();


try {
    final result = await api_instance.monitoringPerformanceSlow();
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->monitoringPerformanceSlow: $e\n');
}

import org.openapitools.client.api.MonitoringApi;

public class MonitoringApiExample {
    public static void main(String[] args) {
        MonitoringApi apiInstance = new MonitoringApi();

        try {
            monitoring_performance_summary_200_response result = apiInstance.monitoringPerformanceSlow();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling MonitoringApi#monitoringPerformanceSlow");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: cookieAuth)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"domainflow_session"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"domainflow_session"];


// Create an instance of the API class
MonitoringApi *apiInstance = [[MonitoringApi alloc] init];

// Monitoring performance slow
[apiInstance monitoringPerformanceSlowWithCompletionHandler: 
              ^(monitoring_performance_summary_200_response output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var DomainFlowApi = require('domain_flow_api');
var defaultClient = DomainFlowApi.ApiClient.instance;

// Configure API key authorization: cookieAuth
var cookieAuth = defaultClient.authentications['cookieAuth'];
cookieAuth.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//cookieAuth.apiKeyPrefix['domainflow_session'] = "Token";

// Create an instance of the API class
var api = new DomainFlowApi.MonitoringApi()
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.monitoringPerformanceSlow(callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class monitoringPerformanceSlowExample
    {
        public void main()
        {
            // Configure API key authorization: cookieAuth
            Configuration.Default.ApiKey.Add("domainflow_session", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("domainflow_session", "Bearer");

            // Create an instance of the API class
            var apiInstance = new MonitoringApi();

            try {
                // Monitoring performance slow
                monitoring_performance_summary_200_response result = apiInstance.monitoringPerformanceSlow();
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling MonitoringApi.monitoringPerformanceSlow: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure API key authorization: cookieAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('domainflow_session', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('domainflow_session', 'Bearer');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\MonitoringApi();

try {
    $result = $api_instance->monitoringPerformanceSlow();
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling MonitoringApi->monitoringPerformanceSlow: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::MonitoringApi;

# Configure API key authorization: cookieAuth
$WWW::OPenAPIClient::Configuration::api_key->{'domainflow_session'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'domainflow_session'} = "Bearer";

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::MonitoringApi->new();

eval {
    my $result = $api_instance->monitoringPerformanceSlow();
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling MonitoringApi->monitoringPerformanceSlow: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure API key authorization: cookieAuth
openapi_client.configuration.api_key['domainflow_session'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['domainflow_session'] = 'Bearer'

# Create an instance of the API class
api_instance = openapi_client.MonitoringApi()

try:
    # Monitoring performance slow
    api_response = api_instance.monitoring_performance_slow()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling MonitoringApi->monitoringPerformanceSlow: %s\n" % e)
extern crate MonitoringApi;

pub fn main() {

    let mut context = MonitoringApi::Context::default();
    let result = client.monitoringPerformanceSlow(&context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Responses


monitoringPerformanceSummary

Monitoring performance summary


/monitoring/performance/summary

Usage and SDK Samples

curl -X GET \
 \
 -H "Accept: application/json" \
 "https://api.domainflow.dev/api/v2/monitoring/performance/summary"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.MonitoringApi;

import java.io.File;
import java.util.*;

public class MonitoringApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure API key authorization: cookieAuth
        ApiKeyAuth cookieAuth = (ApiKeyAuth) defaultClient.getAuthentication("cookieAuth");
        cookieAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //cookieAuth.setApiKeyPrefix("Token");

        // Create an instance of the API class
        MonitoringApi apiInstance = new MonitoringApi();

        try {
            monitoring_performance_summary_200_response result = apiInstance.monitoringPerformanceSummary();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling MonitoringApi#monitoringPerformanceSummary");
            e.printStackTrace();
        }
    }
}
import 'package:openapi/api.dart';

final api_instance = DefaultApi();


try {
    final result = await api_instance.monitoringPerformanceSummary();
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->monitoringPerformanceSummary: $e\n');
}

import org.openapitools.client.api.MonitoringApi;

public class MonitoringApiExample {
    public static void main(String[] args) {
        MonitoringApi apiInstance = new MonitoringApi();

        try {
            monitoring_performance_summary_200_response result = apiInstance.monitoringPerformanceSummary();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling MonitoringApi#monitoringPerformanceSummary");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: cookieAuth)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"domainflow_session"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"domainflow_session"];


// Create an instance of the API class
MonitoringApi *apiInstance = [[MonitoringApi alloc] init];

// Monitoring performance summary
[apiInstance monitoringPerformanceSummaryWithCompletionHandler: 
              ^(monitoring_performance_summary_200_response output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var DomainFlowApi = require('domain_flow_api');
var defaultClient = DomainFlowApi.ApiClient.instance;

// Configure API key authorization: cookieAuth
var cookieAuth = defaultClient.authentications['cookieAuth'];
cookieAuth.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//cookieAuth.apiKeyPrefix['domainflow_session'] = "Token";

// Create an instance of the API class
var api = new DomainFlowApi.MonitoringApi()
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.monitoringPerformanceSummary(callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class monitoringPerformanceSummaryExample
    {
        public void main()
        {
            // Configure API key authorization: cookieAuth
            Configuration.Default.ApiKey.Add("domainflow_session", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("domainflow_session", "Bearer");

            // Create an instance of the API class
            var apiInstance = new MonitoringApi();

            try {
                // Monitoring performance summary
                monitoring_performance_summary_200_response result = apiInstance.monitoringPerformanceSummary();
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling MonitoringApi.monitoringPerformanceSummary: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure API key authorization: cookieAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('domainflow_session', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('domainflow_session', 'Bearer');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\MonitoringApi();

try {
    $result = $api_instance->monitoringPerformanceSummary();
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling MonitoringApi->monitoringPerformanceSummary: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::MonitoringApi;

# Configure API key authorization: cookieAuth
$WWW::OPenAPIClient::Configuration::api_key->{'domainflow_session'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'domainflow_session'} = "Bearer";

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::MonitoringApi->new();

eval {
    my $result = $api_instance->monitoringPerformanceSummary();
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling MonitoringApi->monitoringPerformanceSummary: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure API key authorization: cookieAuth
openapi_client.configuration.api_key['domainflow_session'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['domainflow_session'] = 'Bearer'

# Create an instance of the API class
api_instance = openapi_client.MonitoringApi()

try:
    # Monitoring performance summary
    api_response = api_instance.monitoring_performance_summary()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling MonitoringApi->monitoringPerformanceSummary: %s\n" % e)
extern crate MonitoringApi;

pub fn main() {

    let mut context = MonitoringApi::Context::default();
    let result = client.monitoringPerformanceSummary(&context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Responses


monitoringPerformanceTrends

Monitoring performance trends


/monitoring/dashboard/trends

Usage and SDK Samples

curl -X GET \
 \
 -H "Accept: application/json" \
 "https://api.domainflow.dev/api/v2/monitoring/dashboard/trends"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.MonitoringApi;

import java.io.File;
import java.util.*;

public class MonitoringApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure API key authorization: cookieAuth
        ApiKeyAuth cookieAuth = (ApiKeyAuth) defaultClient.getAuthentication("cookieAuth");
        cookieAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //cookieAuth.setApiKeyPrefix("Token");

        // Create an instance of the API class
        MonitoringApi apiInstance = new MonitoringApi();

        try {
            monitoring_performance_summary_200_response result = apiInstance.monitoringPerformanceTrends();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling MonitoringApi#monitoringPerformanceTrends");
            e.printStackTrace();
        }
    }
}
import 'package:openapi/api.dart';

final api_instance = DefaultApi();


try {
    final result = await api_instance.monitoringPerformanceTrends();
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->monitoringPerformanceTrends: $e\n');
}

import org.openapitools.client.api.MonitoringApi;

public class MonitoringApiExample {
    public static void main(String[] args) {
        MonitoringApi apiInstance = new MonitoringApi();

        try {
            monitoring_performance_summary_200_response result = apiInstance.monitoringPerformanceTrends();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling MonitoringApi#monitoringPerformanceTrends");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: cookieAuth)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"domainflow_session"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"domainflow_session"];


// Create an instance of the API class
MonitoringApi *apiInstance = [[MonitoringApi alloc] init];

// Monitoring performance trends
[apiInstance monitoringPerformanceTrendsWithCompletionHandler: 
              ^(monitoring_performance_summary_200_response output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var DomainFlowApi = require('domain_flow_api');
var defaultClient = DomainFlowApi.ApiClient.instance;

// Configure API key authorization: cookieAuth
var cookieAuth = defaultClient.authentications['cookieAuth'];
cookieAuth.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//cookieAuth.apiKeyPrefix['domainflow_session'] = "Token";

// Create an instance of the API class
var api = new DomainFlowApi.MonitoringApi()
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.monitoringPerformanceTrends(callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class monitoringPerformanceTrendsExample
    {
        public void main()
        {
            // Configure API key authorization: cookieAuth
            Configuration.Default.ApiKey.Add("domainflow_session", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("domainflow_session", "Bearer");

            // Create an instance of the API class
            var apiInstance = new MonitoringApi();

            try {
                // Monitoring performance trends
                monitoring_performance_summary_200_response result = apiInstance.monitoringPerformanceTrends();
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling MonitoringApi.monitoringPerformanceTrends: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure API key authorization: cookieAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('domainflow_session', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('domainflow_session', 'Bearer');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\MonitoringApi();

try {
    $result = $api_instance->monitoringPerformanceTrends();
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling MonitoringApi->monitoringPerformanceTrends: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::MonitoringApi;

# Configure API key authorization: cookieAuth
$WWW::OPenAPIClient::Configuration::api_key->{'domainflow_session'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'domainflow_session'} = "Bearer";

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::MonitoringApi->new();

eval {
    my $result = $api_instance->monitoringPerformanceTrends();
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling MonitoringApi->monitoringPerformanceTrends: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure API key authorization: cookieAuth
openapi_client.configuration.api_key['domainflow_session'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['domainflow_session'] = 'Bearer'

# Create an instance of the API class
api_instance = openapi_client.MonitoringApi()

try:
    # Monitoring performance trends
    api_response = api_instance.monitoring_performance_trends()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling MonitoringApi->monitoringPerformanceTrends: %s\n" % e)
extern crate MonitoringApi;

pub fn main() {

    let mut context = MonitoringApi::Context::default();
    let result = client.monitoringPerformanceTrends(&context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Responses


monitoringResourcesAlerts

System resources alerts


/monitoring/resources/alerts

Usage and SDK Samples

curl -X GET \
 \
 -H "Accept: application/json" \
 "https://api.domainflow.dev/api/v2/monitoring/resources/alerts"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.MonitoringApi;

import java.io.File;
import java.util.*;

public class MonitoringApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure API key authorization: cookieAuth
        ApiKeyAuth cookieAuth = (ApiKeyAuth) defaultClient.getAuthentication("cookieAuth");
        cookieAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //cookieAuth.setApiKeyPrefix("Token");

        // Create an instance of the API class
        MonitoringApi apiInstance = new MonitoringApi();

        try {
            monitoring_performance_summary_200_response result = apiInstance.monitoringResourcesAlerts();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling MonitoringApi#monitoringResourcesAlerts");
            e.printStackTrace();
        }
    }
}
import 'package:openapi/api.dart';

final api_instance = DefaultApi();


try {
    final result = await api_instance.monitoringResourcesAlerts();
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->monitoringResourcesAlerts: $e\n');
}

import org.openapitools.client.api.MonitoringApi;

public class MonitoringApiExample {
    public static void main(String[] args) {
        MonitoringApi apiInstance = new MonitoringApi();

        try {
            monitoring_performance_summary_200_response result = apiInstance.monitoringResourcesAlerts();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling MonitoringApi#monitoringResourcesAlerts");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: cookieAuth)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"domainflow_session"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"domainflow_session"];


// Create an instance of the API class
MonitoringApi *apiInstance = [[MonitoringApi alloc] init];

// System resources alerts
[apiInstance monitoringResourcesAlertsWithCompletionHandler: 
              ^(monitoring_performance_summary_200_response output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var DomainFlowApi = require('domain_flow_api');
var defaultClient = DomainFlowApi.ApiClient.instance;

// Configure API key authorization: cookieAuth
var cookieAuth = defaultClient.authentications['cookieAuth'];
cookieAuth.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//cookieAuth.apiKeyPrefix['domainflow_session'] = "Token";

// Create an instance of the API class
var api = new DomainFlowApi.MonitoringApi()
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.monitoringResourcesAlerts(callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class monitoringResourcesAlertsExample
    {
        public void main()
        {
            // Configure API key authorization: cookieAuth
            Configuration.Default.ApiKey.Add("domainflow_session", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("domainflow_session", "Bearer");

            // Create an instance of the API class
            var apiInstance = new MonitoringApi();

            try {
                // System resources alerts
                monitoring_performance_summary_200_response result = apiInstance.monitoringResourcesAlerts();
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling MonitoringApi.monitoringResourcesAlerts: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure API key authorization: cookieAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('domainflow_session', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('domainflow_session', 'Bearer');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\MonitoringApi();

try {
    $result = $api_instance->monitoringResourcesAlerts();
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling MonitoringApi->monitoringResourcesAlerts: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::MonitoringApi;

# Configure API key authorization: cookieAuth
$WWW::OPenAPIClient::Configuration::api_key->{'domainflow_session'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'domainflow_session'} = "Bearer";

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::MonitoringApi->new();

eval {
    my $result = $api_instance->monitoringResourcesAlerts();
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling MonitoringApi->monitoringResourcesAlerts: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure API key authorization: cookieAuth
openapi_client.configuration.api_key['domainflow_session'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['domainflow_session'] = 'Bearer'

# Create an instance of the API class
api_instance = openapi_client.MonitoringApi()

try:
    # System resources alerts
    api_response = api_instance.monitoring_resources_alerts()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling MonitoringApi->monitoringResourcesAlerts: %s\n" % e)
extern crate MonitoringApi;

pub fn main() {

    let mut context = MonitoringApi::Context::default();
    let result = client.monitoringResourcesAlerts(&context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Responses


monitoringResourcesHistory

System resources history


/monitoring/resources/history

Usage and SDK Samples

curl -X GET \
 \
 -H "Accept: application/json" \
 "https://api.domainflow.dev/api/v2/monitoring/resources/history"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.MonitoringApi;

import java.io.File;
import java.util.*;

public class MonitoringApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure API key authorization: cookieAuth
        ApiKeyAuth cookieAuth = (ApiKeyAuth) defaultClient.getAuthentication("cookieAuth");
        cookieAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //cookieAuth.setApiKeyPrefix("Token");

        // Create an instance of the API class
        MonitoringApi apiInstance = new MonitoringApi();

        try {
            monitoring_performance_summary_200_response result = apiInstance.monitoringResourcesHistory();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling MonitoringApi#monitoringResourcesHistory");
            e.printStackTrace();
        }
    }
}
import 'package:openapi/api.dart';

final api_instance = DefaultApi();


try {
    final result = await api_instance.monitoringResourcesHistory();
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->monitoringResourcesHistory: $e\n');
}

import org.openapitools.client.api.MonitoringApi;

public class MonitoringApiExample {
    public static void main(String[] args) {
        MonitoringApi apiInstance = new MonitoringApi();

        try {
            monitoring_performance_summary_200_response result = apiInstance.monitoringResourcesHistory();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling MonitoringApi#monitoringResourcesHistory");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: cookieAuth)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"domainflow_session"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"domainflow_session"];


// Create an instance of the API class
MonitoringApi *apiInstance = [[MonitoringApi alloc] init];

// System resources history
[apiInstance monitoringResourcesHistoryWithCompletionHandler: 
              ^(monitoring_performance_summary_200_response output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var DomainFlowApi = require('domain_flow_api');
var defaultClient = DomainFlowApi.ApiClient.instance;

// Configure API key authorization: cookieAuth
var cookieAuth = defaultClient.authentications['cookieAuth'];
cookieAuth.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//cookieAuth.apiKeyPrefix['domainflow_session'] = "Token";

// Create an instance of the API class
var api = new DomainFlowApi.MonitoringApi()
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.monitoringResourcesHistory(callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class monitoringResourcesHistoryExample
    {
        public void main()
        {
            // Configure API key authorization: cookieAuth
            Configuration.Default.ApiKey.Add("domainflow_session", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("domainflow_session", "Bearer");

            // Create an instance of the API class
            var apiInstance = new MonitoringApi();

            try {
                // System resources history
                monitoring_performance_summary_200_response result = apiInstance.monitoringResourcesHistory();
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling MonitoringApi.monitoringResourcesHistory: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure API key authorization: cookieAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('domainflow_session', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('domainflow_session', 'Bearer');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\MonitoringApi();

try {
    $result = $api_instance->monitoringResourcesHistory();
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling MonitoringApi->monitoringResourcesHistory: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::MonitoringApi;

# Configure API key authorization: cookieAuth
$WWW::OPenAPIClient::Configuration::api_key->{'domainflow_session'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'domainflow_session'} = "Bearer";

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::MonitoringApi->new();

eval {
    my $result = $api_instance->monitoringResourcesHistory();
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling MonitoringApi->monitoringResourcesHistory: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure API key authorization: cookieAuth
openapi_client.configuration.api_key['domainflow_session'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['domainflow_session'] = 'Bearer'

# Create an instance of the API class
api_instance = openapi_client.MonitoringApi()

try:
    # System resources history
    api_response = api_instance.monitoring_resources_history()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling MonitoringApi->monitoringResourcesHistory: %s\n" % e)
extern crate MonitoringApi;

pub fn main() {

    let mut context = MonitoringApi::Context::default();
    let result = client.monitoringResourcesHistory(&context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Responses


monitoringResourcesSystem

System resources


/monitoring/resources/system

Usage and SDK Samples

curl -X GET \
 \
 -H "Accept: application/json" \
 "https://api.domainflow.dev/api/v2/monitoring/resources/system"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.MonitoringApi;

import java.io.File;
import java.util.*;

public class MonitoringApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure API key authorization: cookieAuth
        ApiKeyAuth cookieAuth = (ApiKeyAuth) defaultClient.getAuthentication("cookieAuth");
        cookieAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //cookieAuth.setApiKeyPrefix("Token");

        // Create an instance of the API class
        MonitoringApi apiInstance = new MonitoringApi();

        try {
            monitoring_performance_summary_200_response result = apiInstance.monitoringResourcesSystem();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling MonitoringApi#monitoringResourcesSystem");
            e.printStackTrace();
        }
    }
}
import 'package:openapi/api.dart';

final api_instance = DefaultApi();


try {
    final result = await api_instance.monitoringResourcesSystem();
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->monitoringResourcesSystem: $e\n');
}

import org.openapitools.client.api.MonitoringApi;

public class MonitoringApiExample {
    public static void main(String[] args) {
        MonitoringApi apiInstance = new MonitoringApi();

        try {
            monitoring_performance_summary_200_response result = apiInstance.monitoringResourcesSystem();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling MonitoringApi#monitoringResourcesSystem");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: cookieAuth)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"domainflow_session"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"domainflow_session"];


// Create an instance of the API class
MonitoringApi *apiInstance = [[MonitoringApi alloc] init];

// System resources
[apiInstance monitoringResourcesSystemWithCompletionHandler: 
              ^(monitoring_performance_summary_200_response output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var DomainFlowApi = require('domain_flow_api');
var defaultClient = DomainFlowApi.ApiClient.instance;

// Configure API key authorization: cookieAuth
var cookieAuth = defaultClient.authentications['cookieAuth'];
cookieAuth.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//cookieAuth.apiKeyPrefix['domainflow_session'] = "Token";

// Create an instance of the API class
var api = new DomainFlowApi.MonitoringApi()
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.monitoringResourcesSystem(callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class monitoringResourcesSystemExample
    {
        public void main()
        {
            // Configure API key authorization: cookieAuth
            Configuration.Default.ApiKey.Add("domainflow_session", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("domainflow_session", "Bearer");

            // Create an instance of the API class
            var apiInstance = new MonitoringApi();

            try {
                // System resources
                monitoring_performance_summary_200_response result = apiInstance.monitoringResourcesSystem();
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling MonitoringApi.monitoringResourcesSystem: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure API key authorization: cookieAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('domainflow_session', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('domainflow_session', 'Bearer');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\MonitoringApi();

try {
    $result = $api_instance->monitoringResourcesSystem();
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling MonitoringApi->monitoringResourcesSystem: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::MonitoringApi;

# Configure API key authorization: cookieAuth
$WWW::OPenAPIClient::Configuration::api_key->{'domainflow_session'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'domainflow_session'} = "Bearer";

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::MonitoringApi->new();

eval {
    my $result = $api_instance->monitoringResourcesSystem();
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling MonitoringApi->monitoringResourcesSystem: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure API key authorization: cookieAuth
openapi_client.configuration.api_key['domainflow_session'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['domainflow_session'] = 'Bearer'

# Create an instance of the API class
api_instance = openapi_client.MonitoringApi()

try:
    # System resources
    api_response = api_instance.monitoring_resources_system()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling MonitoringApi->monitoringResourcesSystem: %s\n" % e)
extern crate MonitoringApi;

pub fn main() {

    let mut context = MonitoringApi::Context::default();
    let result = client.monitoringResourcesSystem(&context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Responses


monitoringStats

Monitoring stats


/monitoring/stats

Usage and SDK Samples

curl -X GET \
 \
 -H "Accept: application/json" \
 "https://api.domainflow.dev/api/v2/monitoring/stats"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.MonitoringApi;

import java.io.File;
import java.util.*;

public class MonitoringApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure API key authorization: cookieAuth
        ApiKeyAuth cookieAuth = (ApiKeyAuth) defaultClient.getAuthentication("cookieAuth");
        cookieAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //cookieAuth.setApiKeyPrefix("Token");

        // Create an instance of the API class
        MonitoringApi apiInstance = new MonitoringApi();

        try {
            monitoring_performance_summary_200_response result = apiInstance.monitoringStats();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling MonitoringApi#monitoringStats");
            e.printStackTrace();
        }
    }
}
import 'package:openapi/api.dart';

final api_instance = DefaultApi();


try {
    final result = await api_instance.monitoringStats();
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->monitoringStats: $e\n');
}

import org.openapitools.client.api.MonitoringApi;

public class MonitoringApiExample {
    public static void main(String[] args) {
        MonitoringApi apiInstance = new MonitoringApi();

        try {
            monitoring_performance_summary_200_response result = apiInstance.monitoringStats();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling MonitoringApi#monitoringStats");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: cookieAuth)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"domainflow_session"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"domainflow_session"];


// Create an instance of the API class
MonitoringApi *apiInstance = [[MonitoringApi alloc] init];

// Monitoring stats
[apiInstance monitoringStatsWithCompletionHandler: 
              ^(monitoring_performance_summary_200_response output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var DomainFlowApi = require('domain_flow_api');
var defaultClient = DomainFlowApi.ApiClient.instance;

// Configure API key authorization: cookieAuth
var cookieAuth = defaultClient.authentications['cookieAuth'];
cookieAuth.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//cookieAuth.apiKeyPrefix['domainflow_session'] = "Token";

// Create an instance of the API class
var api = new DomainFlowApi.MonitoringApi()
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.monitoringStats(callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class monitoringStatsExample
    {
        public void main()
        {
            // Configure API key authorization: cookieAuth
            Configuration.Default.ApiKey.Add("domainflow_session", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("domainflow_session", "Bearer");

            // Create an instance of the API class
            var apiInstance = new MonitoringApi();

            try {
                // Monitoring stats
                monitoring_performance_summary_200_response result = apiInstance.monitoringStats();
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling MonitoringApi.monitoringStats: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure API key authorization: cookieAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('domainflow_session', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('domainflow_session', 'Bearer');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\MonitoringApi();

try {
    $result = $api_instance->monitoringStats();
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling MonitoringApi->monitoringStats: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::MonitoringApi;

# Configure API key authorization: cookieAuth
$WWW::OPenAPIClient::Configuration::api_key->{'domainflow_session'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'domainflow_session'} = "Bearer";

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::MonitoringApi->new();

eval {
    my $result = $api_instance->monitoringStats();
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling MonitoringApi->monitoringStats: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure API key authorization: cookieAuth
openapi_client.configuration.api_key['domainflow_session'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['domainflow_session'] = 'Bearer'

# Create an instance of the API class
api_instance = openapi_client.MonitoringApi()

try:
    # Monitoring stats
    api_response = api_instance.monitoring_stats()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling MonitoringApi->monitoringStats: %s\n" % e)
extern crate MonitoringApi;

pub fn main() {

    let mut context = MonitoringApi::Context::default();
    let result = client.monitoringStats(&context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Responses


Personas

personasCreate

Create persona


/personas

Usage and SDK Samples

curl -X POST \
 \
 -H "Accept: application/json" \
 -H "Content-Type: application/json" \
 "https://api.domainflow.dev/api/v2/personas" \
 -d '{
  "personaType" : "dns",
  "configDetails" : {
    "key" : ""
  },
  "isEnabled" : true,
  "name" : "name",
  "description" : "description"
}'
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.PersonasApi;

import java.io.File;
import java.util.*;

public class PersonasApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure API key authorization: cookieAuth
        ApiKeyAuth cookieAuth = (ApiKeyAuth) defaultClient.getAuthentication("cookieAuth");
        cookieAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //cookieAuth.setApiKeyPrefix("Token");

        // Create an instance of the API class
        PersonasApi apiInstance = new PersonasApi();
        CreatePersonaRequest createPersonaRequest = ; // CreatePersonaRequest | 

        try {
            personas_create_201_response result = apiInstance.personasCreate(createPersonaRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling PersonasApi#personasCreate");
            e.printStackTrace();
        }
    }
}
import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final CreatePersonaRequest createPersonaRequest = new CreatePersonaRequest(); // CreatePersonaRequest | 

try {
    final result = await api_instance.personasCreate(createPersonaRequest);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->personasCreate: $e\n');
}

import org.openapitools.client.api.PersonasApi;

public class PersonasApiExample {
    public static void main(String[] args) {
        PersonasApi apiInstance = new PersonasApi();
        CreatePersonaRequest createPersonaRequest = ; // CreatePersonaRequest | 

        try {
            personas_create_201_response result = apiInstance.personasCreate(createPersonaRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling PersonasApi#personasCreate");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: cookieAuth)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"domainflow_session"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"domainflow_session"];


// Create an instance of the API class
PersonasApi *apiInstance = [[PersonasApi alloc] init];
CreatePersonaRequest *createPersonaRequest = ; // 

// Create persona
[apiInstance personasCreateWith:createPersonaRequest
              completionHandler: ^(personas_create_201_response output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var DomainFlowApi = require('domain_flow_api');
var defaultClient = DomainFlowApi.ApiClient.instance;

// Configure API key authorization: cookieAuth
var cookieAuth = defaultClient.authentications['cookieAuth'];
cookieAuth.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//cookieAuth.apiKeyPrefix['domainflow_session'] = "Token";

// Create an instance of the API class
var api = new DomainFlowApi.PersonasApi()
var createPersonaRequest = ; // {CreatePersonaRequest} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.personasCreate(createPersonaRequest, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class personasCreateExample
    {
        public void main()
        {
            // Configure API key authorization: cookieAuth
            Configuration.Default.ApiKey.Add("domainflow_session", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("domainflow_session", "Bearer");

            // Create an instance of the API class
            var apiInstance = new PersonasApi();
            var createPersonaRequest = new CreatePersonaRequest(); // CreatePersonaRequest | 

            try {
                // Create persona
                personas_create_201_response result = apiInstance.personasCreate(createPersonaRequest);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling PersonasApi.personasCreate: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure API key authorization: cookieAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('domainflow_session', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('domainflow_session', 'Bearer');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\PersonasApi();
$createPersonaRequest = ; // CreatePersonaRequest | 

try {
    $result = $api_instance->personasCreate($createPersonaRequest);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling PersonasApi->personasCreate: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::PersonasApi;

# Configure API key authorization: cookieAuth
$WWW::OPenAPIClient::Configuration::api_key->{'domainflow_session'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'domainflow_session'} = "Bearer";

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::PersonasApi->new();
my $createPersonaRequest = WWW::OPenAPIClient::Object::CreatePersonaRequest->new(); # CreatePersonaRequest | 

eval {
    my $result = $api_instance->personasCreate(createPersonaRequest => $createPersonaRequest);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling PersonasApi->personasCreate: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure API key authorization: cookieAuth
openapi_client.configuration.api_key['domainflow_session'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['domainflow_session'] = 'Bearer'

# Create an instance of the API class
api_instance = openapi_client.PersonasApi()
createPersonaRequest =  # CreatePersonaRequest | 

try:
    # Create persona
    api_response = api_instance.personas_create(createPersonaRequest)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling PersonasApi->personasCreate: %s\n" % e)
extern crate PersonasApi;

pub fn main() {
    let createPersonaRequest = ; // CreatePersonaRequest

    let mut context = PersonasApi::Context::default();
    let result = client.personasCreate(createPersonaRequest, &context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Body parameters
Name Description
createPersonaRequest *

Responses

Name Type Format Description
Retry-After Integer Seconds to wait before retrying


personasDelete

Delete persona


/personas/{id}

Usage and SDK Samples

curl -X DELETE \
 \
 -H "Accept: application/json" \
 "https://api.domainflow.dev/api/v2/personas/{id}"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.PersonasApi;

import java.io.File;
import java.util.*;

public class PersonasApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure API key authorization: cookieAuth
        ApiKeyAuth cookieAuth = (ApiKeyAuth) defaultClient.getAuthentication("cookieAuth");
        cookieAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //cookieAuth.setApiKeyPrefix("Token");

        // Create an instance of the API class
        PersonasApi apiInstance = new PersonasApi();
        UUID id = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 

        try {
            personas_delete_200_response result = apiInstance.personasDelete(id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling PersonasApi#personasDelete");
            e.printStackTrace();
        }
    }
}
import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final UUID id = new UUID(); // UUID | 

try {
    final result = await api_instance.personasDelete(id);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->personasDelete: $e\n');
}

import org.openapitools.client.api.PersonasApi;

public class PersonasApiExample {
    public static void main(String[] args) {
        PersonasApi apiInstance = new PersonasApi();
        UUID id = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 

        try {
            personas_delete_200_response result = apiInstance.personasDelete(id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling PersonasApi#personasDelete");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: cookieAuth)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"domainflow_session"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"domainflow_session"];


// Create an instance of the API class
PersonasApi *apiInstance = [[PersonasApi alloc] init];
UUID *id = 38400000-8cf0-11bd-b23e-10b96e4ef00d; //  (default to null)

// Delete persona
[apiInstance personasDeleteWith:id
              completionHandler: ^(personas_delete_200_response output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var DomainFlowApi = require('domain_flow_api');
var defaultClient = DomainFlowApi.ApiClient.instance;

// Configure API key authorization: cookieAuth
var cookieAuth = defaultClient.authentications['cookieAuth'];
cookieAuth.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//cookieAuth.apiKeyPrefix['domainflow_session'] = "Token";

// Create an instance of the API class
var api = new DomainFlowApi.PersonasApi()
var id = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // {UUID} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.personasDelete(id, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class personasDeleteExample
    {
        public void main()
        {
            // Configure API key authorization: cookieAuth
            Configuration.Default.ApiKey.Add("domainflow_session", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("domainflow_session", "Bearer");

            // Create an instance of the API class
            var apiInstance = new PersonasApi();
            var id = 38400000-8cf0-11bd-b23e-10b96e4ef00d;  // UUID |  (default to null)

            try {
                // Delete persona
                personas_delete_200_response result = apiInstance.personasDelete(id);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling PersonasApi.personasDelete: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure API key authorization: cookieAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('domainflow_session', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('domainflow_session', 'Bearer');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\PersonasApi();
$id = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 

try {
    $result = $api_instance->personasDelete($id);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling PersonasApi->personasDelete: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::PersonasApi;

# Configure API key authorization: cookieAuth
$WWW::OPenAPIClient::Configuration::api_key->{'domainflow_session'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'domainflow_session'} = "Bearer";

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::PersonasApi->new();
my $id = 38400000-8cf0-11bd-b23e-10b96e4ef00d; # UUID | 

eval {
    my $result = $api_instance->personasDelete(id => $id);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling PersonasApi->personasDelete: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure API key authorization: cookieAuth
openapi_client.configuration.api_key['domainflow_session'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['domainflow_session'] = 'Bearer'

# Create an instance of the API class
api_instance = openapi_client.PersonasApi()
id = 38400000-8cf0-11bd-b23e-10b96e4ef00d # UUID |  (default to null)

try:
    # Delete persona
    api_response = api_instance.personas_delete(id)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling PersonasApi->personasDelete: %s\n" % e)
extern crate PersonasApi;

pub fn main() {
    let id = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID

    let mut context = PersonasApi::Context::default();
    let result = client.personasDelete(id, &context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Path parameters
Name Description
id*
UUID (uuid)
Required

Responses

Name Type Format Description
Retry-After Integer Seconds to wait before retrying


personasGet

Get persona by ID


/personas/{id}

Usage and SDK Samples

curl -X GET \
 \
 -H "Accept: application/json" \
 "https://api.domainflow.dev/api/v2/personas/{id}"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.PersonasApi;

import java.io.File;
import java.util.*;

public class PersonasApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure API key authorization: cookieAuth
        ApiKeyAuth cookieAuth = (ApiKeyAuth) defaultClient.getAuthentication("cookieAuth");
        cookieAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //cookieAuth.setApiKeyPrefix("Token");

        // Create an instance of the API class
        PersonasApi apiInstance = new PersonasApi();
        UUID id = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 

        try {
            personas_create_201_response result = apiInstance.personasGet(id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling PersonasApi#personasGet");
            e.printStackTrace();
        }
    }
}
import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final UUID id = new UUID(); // UUID | 

try {
    final result = await api_instance.personasGet(id);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->personasGet: $e\n');
}

import org.openapitools.client.api.PersonasApi;

public class PersonasApiExample {
    public static void main(String[] args) {
        PersonasApi apiInstance = new PersonasApi();
        UUID id = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 

        try {
            personas_create_201_response result = apiInstance.personasGet(id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling PersonasApi#personasGet");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: cookieAuth)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"domainflow_session"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"domainflow_session"];


// Create an instance of the API class
PersonasApi *apiInstance = [[PersonasApi alloc] init];
UUID *id = 38400000-8cf0-11bd-b23e-10b96e4ef00d; //  (default to null)

// Get persona by ID
[apiInstance personasGetWith:id
              completionHandler: ^(personas_create_201_response output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var DomainFlowApi = require('domain_flow_api');
var defaultClient = DomainFlowApi.ApiClient.instance;

// Configure API key authorization: cookieAuth
var cookieAuth = defaultClient.authentications['cookieAuth'];
cookieAuth.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//cookieAuth.apiKeyPrefix['domainflow_session'] = "Token";

// Create an instance of the API class
var api = new DomainFlowApi.PersonasApi()
var id = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // {UUID} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.personasGet(id, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class personasGetExample
    {
        public void main()
        {
            // Configure API key authorization: cookieAuth
            Configuration.Default.ApiKey.Add("domainflow_session", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("domainflow_session", "Bearer");

            // Create an instance of the API class
            var apiInstance = new PersonasApi();
            var id = 38400000-8cf0-11bd-b23e-10b96e4ef00d;  // UUID |  (default to null)

            try {
                // Get persona by ID
                personas_create_201_response result = apiInstance.personasGet(id);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling PersonasApi.personasGet: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure API key authorization: cookieAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('domainflow_session', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('domainflow_session', 'Bearer');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\PersonasApi();
$id = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 

try {
    $result = $api_instance->personasGet($id);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling PersonasApi->personasGet: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::PersonasApi;

# Configure API key authorization: cookieAuth
$WWW::OPenAPIClient::Configuration::api_key->{'domainflow_session'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'domainflow_session'} = "Bearer";

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::PersonasApi->new();
my $id = 38400000-8cf0-11bd-b23e-10b96e4ef00d; # UUID | 

eval {
    my $result = $api_instance->personasGet(id => $id);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling PersonasApi->personasGet: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure API key authorization: cookieAuth
openapi_client.configuration.api_key['domainflow_session'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['domainflow_session'] = 'Bearer'

# Create an instance of the API class
api_instance = openapi_client.PersonasApi()
id = 38400000-8cf0-11bd-b23e-10b96e4ef00d # UUID |  (default to null)

try:
    # Get persona by ID
    api_response = api_instance.personas_get(id)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling PersonasApi->personasGet: %s\n" % e)
extern crate PersonasApi;

pub fn main() {
    let id = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID

    let mut context = PersonasApi::Context::default();
    let result = client.personasGet(id, &context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Path parameters
Name Description
id*
UUID (uuid)
Required

Responses

Name Type Format Description
Retry-After Integer Seconds to wait before retrying


personasGetDns

Get DNS persona by ID


/personas/dns/{id}

Usage and SDK Samples

curl -X GET \
 \
 -H "Accept: application/json" \
 "https://api.domainflow.dev/api/v2/personas/dns/{id}"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.PersonasApi;

import java.io.File;
import java.util.*;

public class PersonasApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure API key authorization: cookieAuth
        ApiKeyAuth cookieAuth = (ApiKeyAuth) defaultClient.getAuthentication("cookieAuth");
        cookieAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //cookieAuth.setApiKeyPrefix("Token");

        // Create an instance of the API class
        PersonasApi apiInstance = new PersonasApi();
        UUID id = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 

        try {
            personas_create_201_response result = apiInstance.personasGetDns(id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling PersonasApi#personasGetDns");
            e.printStackTrace();
        }
    }
}
import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final UUID id = new UUID(); // UUID | 

try {
    final result = await api_instance.personasGetDns(id);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->personasGetDns: $e\n');
}

import org.openapitools.client.api.PersonasApi;

public class PersonasApiExample {
    public static void main(String[] args) {
        PersonasApi apiInstance = new PersonasApi();
        UUID id = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 

        try {
            personas_create_201_response result = apiInstance.personasGetDns(id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling PersonasApi#personasGetDns");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: cookieAuth)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"domainflow_session"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"domainflow_session"];


// Create an instance of the API class
PersonasApi *apiInstance = [[PersonasApi alloc] init];
UUID *id = 38400000-8cf0-11bd-b23e-10b96e4ef00d; //  (default to null)

// Get DNS persona by ID
[apiInstance personasGetDnsWith:id
              completionHandler: ^(personas_create_201_response output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var DomainFlowApi = require('domain_flow_api');
var defaultClient = DomainFlowApi.ApiClient.instance;

// Configure API key authorization: cookieAuth
var cookieAuth = defaultClient.authentications['cookieAuth'];
cookieAuth.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//cookieAuth.apiKeyPrefix['domainflow_session'] = "Token";

// Create an instance of the API class
var api = new DomainFlowApi.PersonasApi()
var id = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // {UUID} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.personasGetDns(id, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class personasGetDnsExample
    {
        public void main()
        {
            // Configure API key authorization: cookieAuth
            Configuration.Default.ApiKey.Add("domainflow_session", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("domainflow_session", "Bearer");

            // Create an instance of the API class
            var apiInstance = new PersonasApi();
            var id = 38400000-8cf0-11bd-b23e-10b96e4ef00d;  // UUID |  (default to null)

            try {
                // Get DNS persona by ID
                personas_create_201_response result = apiInstance.personasGetDns(id);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling PersonasApi.personasGetDns: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure API key authorization: cookieAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('domainflow_session', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('domainflow_session', 'Bearer');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\PersonasApi();
$id = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 

try {
    $result = $api_instance->personasGetDns($id);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling PersonasApi->personasGetDns: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::PersonasApi;

# Configure API key authorization: cookieAuth
$WWW::OPenAPIClient::Configuration::api_key->{'domainflow_session'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'domainflow_session'} = "Bearer";

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::PersonasApi->new();
my $id = 38400000-8cf0-11bd-b23e-10b96e4ef00d; # UUID | 

eval {
    my $result = $api_instance->personasGetDns(id => $id);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling PersonasApi->personasGetDns: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure API key authorization: cookieAuth
openapi_client.configuration.api_key['domainflow_session'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['domainflow_session'] = 'Bearer'

# Create an instance of the API class
api_instance = openapi_client.PersonasApi()
id = 38400000-8cf0-11bd-b23e-10b96e4ef00d # UUID |  (default to null)

try:
    # Get DNS persona by ID
    api_response = api_instance.personas_get_dns(id)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling PersonasApi->personasGetDns: %s\n" % e)
extern crate PersonasApi;

pub fn main() {
    let id = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID

    let mut context = PersonasApi::Context::default();
    let result = client.personasGetDns(id, &context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Path parameters
Name Description
id*
UUID (uuid)
Required

Responses


personasGetHttp

Get HTTP persona by ID


/personas/http/{id}

Usage and SDK Samples

curl -X GET \
 \
 -H "Accept: application/json" \
 "https://api.domainflow.dev/api/v2/personas/http/{id}"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.PersonasApi;

import java.io.File;
import java.util.*;

public class PersonasApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure API key authorization: cookieAuth
        ApiKeyAuth cookieAuth = (ApiKeyAuth) defaultClient.getAuthentication("cookieAuth");
        cookieAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //cookieAuth.setApiKeyPrefix("Token");

        // Create an instance of the API class
        PersonasApi apiInstance = new PersonasApi();
        UUID id = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 

        try {
            personas_create_201_response result = apiInstance.personasGetHttp(id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling PersonasApi#personasGetHttp");
            e.printStackTrace();
        }
    }
}
import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final UUID id = new UUID(); // UUID | 

try {
    final result = await api_instance.personasGetHttp(id);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->personasGetHttp: $e\n');
}

import org.openapitools.client.api.PersonasApi;

public class PersonasApiExample {
    public static void main(String[] args) {
        PersonasApi apiInstance = new PersonasApi();
        UUID id = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 

        try {
            personas_create_201_response result = apiInstance.personasGetHttp(id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling PersonasApi#personasGetHttp");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: cookieAuth)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"domainflow_session"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"domainflow_session"];


// Create an instance of the API class
PersonasApi *apiInstance = [[PersonasApi alloc] init];
UUID *id = 38400000-8cf0-11bd-b23e-10b96e4ef00d; //  (default to null)

// Get HTTP persona by ID
[apiInstance personasGetHttpWith:id
              completionHandler: ^(personas_create_201_response output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var DomainFlowApi = require('domain_flow_api');
var defaultClient = DomainFlowApi.ApiClient.instance;

// Configure API key authorization: cookieAuth
var cookieAuth = defaultClient.authentications['cookieAuth'];
cookieAuth.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//cookieAuth.apiKeyPrefix['domainflow_session'] = "Token";

// Create an instance of the API class
var api = new DomainFlowApi.PersonasApi()
var id = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // {UUID} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.personasGetHttp(id, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class personasGetHttpExample
    {
        public void main()
        {
            // Configure API key authorization: cookieAuth
            Configuration.Default.ApiKey.Add("domainflow_session", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("domainflow_session", "Bearer");

            // Create an instance of the API class
            var apiInstance = new PersonasApi();
            var id = 38400000-8cf0-11bd-b23e-10b96e4ef00d;  // UUID |  (default to null)

            try {
                // Get HTTP persona by ID
                personas_create_201_response result = apiInstance.personasGetHttp(id);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling PersonasApi.personasGetHttp: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure API key authorization: cookieAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('domainflow_session', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('domainflow_session', 'Bearer');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\PersonasApi();
$id = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 

try {
    $result = $api_instance->personasGetHttp($id);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling PersonasApi->personasGetHttp: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::PersonasApi;

# Configure API key authorization: cookieAuth
$WWW::OPenAPIClient::Configuration::api_key->{'domainflow_session'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'domainflow_session'} = "Bearer";

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::PersonasApi->new();
my $id = 38400000-8cf0-11bd-b23e-10b96e4ef00d; # UUID | 

eval {
    my $result = $api_instance->personasGetHttp(id => $id);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling PersonasApi->personasGetHttp: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure API key authorization: cookieAuth
openapi_client.configuration.api_key['domainflow_session'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['domainflow_session'] = 'Bearer'

# Create an instance of the API class
api_instance = openapi_client.PersonasApi()
id = 38400000-8cf0-11bd-b23e-10b96e4ef00d # UUID |  (default to null)

try:
    # Get HTTP persona by ID
    api_response = api_instance.personas_get_http(id)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling PersonasApi->personasGetHttp: %s\n" % e)
extern crate PersonasApi;

pub fn main() {
    let id = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID

    let mut context = PersonasApi::Context::default();
    let result = client.personasGetHttp(id, &context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Path parameters
Name Description
id*
UUID (uuid)
Required

Responses


personasList

List personas


/personas

Usage and SDK Samples

curl -X GET \
 \
 -H "Accept: application/json" \
 "https://api.domainflow.dev/api/v2/personas?limit=56&offset=56&isEnabled=true&personaType="
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.PersonasApi;

import java.io.File;
import java.util.*;

public class PersonasApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure API key authorization: cookieAuth
        ApiKeyAuth cookieAuth = (ApiKeyAuth) defaultClient.getAuthentication("cookieAuth");
        cookieAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //cookieAuth.setApiKeyPrefix("Token");

        // Create an instance of the API class
        PersonasApi apiInstance = new PersonasApi();
        Integer limit = 56; // Integer | Page size (items per page)
        Integer offset = 56; // Integer | Zero-based offset
        Boolean isEnabled = true; // Boolean | Filter by enabled state
        PersonaType personaType = ; // PersonaType | Filter by persona type

        try {
            personas_list_200_response result = apiInstance.personasList(limit, offset, isEnabled, personaType);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling PersonasApi#personasList");
            e.printStackTrace();
        }
    }
}
import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final Integer limit = new Integer(); // Integer | Page size (items per page)
final Integer offset = new Integer(); // Integer | Zero-based offset
final Boolean isEnabled = new Boolean(); // Boolean | Filter by enabled state
final PersonaType personaType = new PersonaType(); // PersonaType | Filter by persona type

try {
    final result = await api_instance.personasList(limit, offset, isEnabled, personaType);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->personasList: $e\n');
}

import org.openapitools.client.api.PersonasApi;

public class PersonasApiExample {
    public static void main(String[] args) {
        PersonasApi apiInstance = new PersonasApi();
        Integer limit = 56; // Integer | Page size (items per page)
        Integer offset = 56; // Integer | Zero-based offset
        Boolean isEnabled = true; // Boolean | Filter by enabled state
        PersonaType personaType = ; // PersonaType | Filter by persona type

        try {
            personas_list_200_response result = apiInstance.personasList(limit, offset, isEnabled, personaType);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling PersonasApi#personasList");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: cookieAuth)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"domainflow_session"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"domainflow_session"];


// Create an instance of the API class
PersonasApi *apiInstance = [[PersonasApi alloc] init];
Integer *limit = 56; // Page size (items per page) (optional) (default to 50)
Integer *offset = 56; // Zero-based offset (optional) (default to 0)
Boolean *isEnabled = true; // Filter by enabled state (optional) (default to null)
PersonaType *personaType = ; // Filter by persona type (optional) (default to null)

// List personas
[apiInstance personasListWith:limit
    offset:offset
    isEnabled:isEnabled
    personaType:personaType
              completionHandler: ^(personas_list_200_response output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var DomainFlowApi = require('domain_flow_api');
var defaultClient = DomainFlowApi.ApiClient.instance;

// Configure API key authorization: cookieAuth
var cookieAuth = defaultClient.authentications['cookieAuth'];
cookieAuth.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//cookieAuth.apiKeyPrefix['domainflow_session'] = "Token";

// Create an instance of the API class
var api = new DomainFlowApi.PersonasApi()
var opts = {
  'limit': 56, // {Integer} Page size (items per page)
  'offset': 56, // {Integer} Zero-based offset
  'isEnabled': true, // {Boolean} Filter by enabled state
  'personaType':  // {PersonaType} Filter by persona type
};

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.personasList(opts, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class personasListExample
    {
        public void main()
        {
            // Configure API key authorization: cookieAuth
            Configuration.Default.ApiKey.Add("domainflow_session", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("domainflow_session", "Bearer");

            // Create an instance of the API class
            var apiInstance = new PersonasApi();
            var limit = 56;  // Integer | Page size (items per page) (optional)  (default to 50)
            var offset = 56;  // Integer | Zero-based offset (optional)  (default to 0)
            var isEnabled = true;  // Boolean | Filter by enabled state (optional)  (default to null)
            var personaType = new PersonaType(); // PersonaType | Filter by persona type (optional)  (default to null)

            try {
                // List personas
                personas_list_200_response result = apiInstance.personasList(limit, offset, isEnabled, personaType);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling PersonasApi.personasList: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure API key authorization: cookieAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('domainflow_session', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('domainflow_session', 'Bearer');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\PersonasApi();
$limit = 56; // Integer | Page size (items per page)
$offset = 56; // Integer | Zero-based offset
$isEnabled = true; // Boolean | Filter by enabled state
$personaType = ; // PersonaType | Filter by persona type

try {
    $result = $api_instance->personasList($limit, $offset, $isEnabled, $personaType);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling PersonasApi->personasList: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::PersonasApi;

# Configure API key authorization: cookieAuth
$WWW::OPenAPIClient::Configuration::api_key->{'domainflow_session'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'domainflow_session'} = "Bearer";

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::PersonasApi->new();
my $limit = 56; # Integer | Page size (items per page)
my $offset = 56; # Integer | Zero-based offset
my $isEnabled = true; # Boolean | Filter by enabled state
my $personaType = ; # PersonaType | Filter by persona type

eval {
    my $result = $api_instance->personasList(limit => $limit, offset => $offset, isEnabled => $isEnabled, personaType => $personaType);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling PersonasApi->personasList: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure API key authorization: cookieAuth
openapi_client.configuration.api_key['domainflow_session'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['domainflow_session'] = 'Bearer'

# Create an instance of the API class
api_instance = openapi_client.PersonasApi()
limit = 56 # Integer | Page size (items per page) (optional) (default to 50)
offset = 56 # Integer | Zero-based offset (optional) (default to 0)
isEnabled = true # Boolean | Filter by enabled state (optional) (default to null)
personaType =  # PersonaType | Filter by persona type (optional) (default to null)

try:
    # List personas
    api_response = api_instance.personas_list(limit=limit, offset=offset, isEnabled=isEnabled, personaType=personaType)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling PersonasApi->personasList: %s\n" % e)
extern crate PersonasApi;

pub fn main() {
    let limit = 56; // Integer
    let offset = 56; // Integer
    let isEnabled = true; // Boolean
    let personaType = ; // PersonaType

    let mut context = PersonasApi::Context::default();
    let result = client.personasList(limit, offset, isEnabled, personaType, &context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Query parameters
Name Description
limit
Integer
Page size (items per page)
offset
Integer
Zero-based offset
isEnabled
Boolean
Filter by enabled state
personaType
PersonaType
Filter by persona type

Responses

Name Type Format Description
Retry-After Integer Seconds to wait before retrying


personasTest

Test persona


/personas/{id}/test

Usage and SDK Samples

curl -X POST \
 \
 -H "Accept: application/json" \
 "https://api.domainflow.dev/api/v2/personas/{id}/test"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.PersonasApi;

import java.io.File;
import java.util.*;

public class PersonasApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure API key authorization: cookieAuth
        ApiKeyAuth cookieAuth = (ApiKeyAuth) defaultClient.getAuthentication("cookieAuth");
        cookieAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //cookieAuth.setApiKeyPrefix("Token");

        // Create an instance of the API class
        PersonasApi apiInstance = new PersonasApi();
        UUID id = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 

        try {
            personas_test_200_response result = apiInstance.personasTest(id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling PersonasApi#personasTest");
            e.printStackTrace();
        }
    }
}
import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final UUID id = new UUID(); // UUID | 

try {
    final result = await api_instance.personasTest(id);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->personasTest: $e\n');
}

import org.openapitools.client.api.PersonasApi;

public class PersonasApiExample {
    public static void main(String[] args) {
        PersonasApi apiInstance = new PersonasApi();
        UUID id = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 

        try {
            personas_test_200_response result = apiInstance.personasTest(id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling PersonasApi#personasTest");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: cookieAuth)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"domainflow_session"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"domainflow_session"];


// Create an instance of the API class
PersonasApi *apiInstance = [[PersonasApi alloc] init];
UUID *id = 38400000-8cf0-11bd-b23e-10b96e4ef00d; //  (default to null)

// Test persona
[apiInstance personasTestWith:id
              completionHandler: ^(personas_test_200_response output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var DomainFlowApi = require('domain_flow_api');
var defaultClient = DomainFlowApi.ApiClient.instance;

// Configure API key authorization: cookieAuth
var cookieAuth = defaultClient.authentications['cookieAuth'];
cookieAuth.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//cookieAuth.apiKeyPrefix['domainflow_session'] = "Token";

// Create an instance of the API class
var api = new DomainFlowApi.PersonasApi()
var id = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // {UUID} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.personasTest(id, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class personasTestExample
    {
        public void main()
        {
            // Configure API key authorization: cookieAuth
            Configuration.Default.ApiKey.Add("domainflow_session", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("domainflow_session", "Bearer");

            // Create an instance of the API class
            var apiInstance = new PersonasApi();
            var id = 38400000-8cf0-11bd-b23e-10b96e4ef00d;  // UUID |  (default to null)

            try {
                // Test persona
                personas_test_200_response result = apiInstance.personasTest(id);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling PersonasApi.personasTest: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure API key authorization: cookieAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('domainflow_session', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('domainflow_session', 'Bearer');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\PersonasApi();
$id = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 

try {
    $result = $api_instance->personasTest($id);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling PersonasApi->personasTest: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::PersonasApi;

# Configure API key authorization: cookieAuth
$WWW::OPenAPIClient::Configuration::api_key->{'domainflow_session'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'domainflow_session'} = "Bearer";

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::PersonasApi->new();
my $id = 38400000-8cf0-11bd-b23e-10b96e4ef00d; # UUID | 

eval {
    my $result = $api_instance->personasTest(id => $id);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling PersonasApi->personasTest: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure API key authorization: cookieAuth
openapi_client.configuration.api_key['domainflow_session'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['domainflow_session'] = 'Bearer'

# Create an instance of the API class
api_instance = openapi_client.PersonasApi()
id = 38400000-8cf0-11bd-b23e-10b96e4ef00d # UUID |  (default to null)

try:
    # Test persona
    api_response = api_instance.personas_test(id)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling PersonasApi->personasTest: %s\n" % e)
extern crate PersonasApi;

pub fn main() {
    let id = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID

    let mut context = PersonasApi::Context::default();
    let result = client.personasTest(id, &context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Path parameters
Name Description
id*
UUID (uuid)
Required

Responses

Name Type Format Description
Retry-After Integer Seconds to wait before retrying


personasUpdate

Update persona


/personas/{id}

Usage and SDK Samples

curl -X PUT \
 \
 -H "Accept: application/json" \
 -H "Content-Type: application/json" \
 "https://api.domainflow.dev/api/v2/personas/{id}" \
 -d '{
  "configDetails" : {
    "key" : ""
  },
  "isEnabled" : true,
  "name" : "name",
  "description" : "description"
}'
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.PersonasApi;

import java.io.File;
import java.util.*;

public class PersonasApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure API key authorization: cookieAuth
        ApiKeyAuth cookieAuth = (ApiKeyAuth) defaultClient.getAuthentication("cookieAuth");
        cookieAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //cookieAuth.setApiKeyPrefix("Token");

        // Create an instance of the API class
        PersonasApi apiInstance = new PersonasApi();
        UUID id = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 
        UpdatePersonaRequest updatePersonaRequest = ; // UpdatePersonaRequest | 

        try {
            personas_create_201_response result = apiInstance.personasUpdate(id, updatePersonaRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling PersonasApi#personasUpdate");
            e.printStackTrace();
        }
    }
}
import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final UUID id = new UUID(); // UUID | 
final UpdatePersonaRequest updatePersonaRequest = new UpdatePersonaRequest(); // UpdatePersonaRequest | 

try {
    final result = await api_instance.personasUpdate(id, updatePersonaRequest);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->personasUpdate: $e\n');
}

import org.openapitools.client.api.PersonasApi;

public class PersonasApiExample {
    public static void main(String[] args) {
        PersonasApi apiInstance = new PersonasApi();
        UUID id = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 
        UpdatePersonaRequest updatePersonaRequest = ; // UpdatePersonaRequest | 

        try {
            personas_create_201_response result = apiInstance.personasUpdate(id, updatePersonaRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling PersonasApi#personasUpdate");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: cookieAuth)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"domainflow_session"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"domainflow_session"];


// Create an instance of the API class
PersonasApi *apiInstance = [[PersonasApi alloc] init];
UUID *id = 38400000-8cf0-11bd-b23e-10b96e4ef00d; //  (default to null)
UpdatePersonaRequest *updatePersonaRequest = ; // 

// Update persona
[apiInstance personasUpdateWith:id
    updatePersonaRequest:updatePersonaRequest
              completionHandler: ^(personas_create_201_response output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var DomainFlowApi = require('domain_flow_api');
var defaultClient = DomainFlowApi.ApiClient.instance;

// Configure API key authorization: cookieAuth
var cookieAuth = defaultClient.authentications['cookieAuth'];
cookieAuth.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//cookieAuth.apiKeyPrefix['domainflow_session'] = "Token";

// Create an instance of the API class
var api = new DomainFlowApi.PersonasApi()
var id = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // {UUID} 
var updatePersonaRequest = ; // {UpdatePersonaRequest} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.personasUpdate(id, updatePersonaRequest, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class personasUpdateExample
    {
        public void main()
        {
            // Configure API key authorization: cookieAuth
            Configuration.Default.ApiKey.Add("domainflow_session", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("domainflow_session", "Bearer");

            // Create an instance of the API class
            var apiInstance = new PersonasApi();
            var id = 38400000-8cf0-11bd-b23e-10b96e4ef00d;  // UUID |  (default to null)
            var updatePersonaRequest = new UpdatePersonaRequest(); // UpdatePersonaRequest | 

            try {
                // Update persona
                personas_create_201_response result = apiInstance.personasUpdate(id, updatePersonaRequest);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling PersonasApi.personasUpdate: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure API key authorization: cookieAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('domainflow_session', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('domainflow_session', 'Bearer');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\PersonasApi();
$id = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 
$updatePersonaRequest = ; // UpdatePersonaRequest | 

try {
    $result = $api_instance->personasUpdate($id, $updatePersonaRequest);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling PersonasApi->personasUpdate: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::PersonasApi;

# Configure API key authorization: cookieAuth
$WWW::OPenAPIClient::Configuration::api_key->{'domainflow_session'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'domainflow_session'} = "Bearer";

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::PersonasApi->new();
my $id = 38400000-8cf0-11bd-b23e-10b96e4ef00d; # UUID | 
my $updatePersonaRequest = WWW::OPenAPIClient::Object::UpdatePersonaRequest->new(); # UpdatePersonaRequest | 

eval {
    my $result = $api_instance->personasUpdate(id => $id, updatePersonaRequest => $updatePersonaRequest);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling PersonasApi->personasUpdate: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure API key authorization: cookieAuth
openapi_client.configuration.api_key['domainflow_session'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['domainflow_session'] = 'Bearer'

# Create an instance of the API class
api_instance = openapi_client.PersonasApi()
id = 38400000-8cf0-11bd-b23e-10b96e4ef00d # UUID |  (default to null)
updatePersonaRequest =  # UpdatePersonaRequest | 

try:
    # Update persona
    api_response = api_instance.personas_update(id, updatePersonaRequest)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling PersonasApi->personasUpdate: %s\n" % e)
extern crate PersonasApi;

pub fn main() {
    let id = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID
    let updatePersonaRequest = ; // UpdatePersonaRequest

    let mut context = PersonasApi::Context::default();
    let result = client.personasUpdate(id, updatePersonaRequest, &context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Path parameters
Name Description
id*
UUID (uuid)
Required
Body parameters
Name Description
updatePersonaRequest *

Responses

Name Type Format Description
Retry-After Integer Seconds to wait before retrying


Proxies

proxiesBulkDelete

Bulk delete proxies


/proxies/bulk/delete

Usage and SDK Samples

curl -X DELETE \
 \
 -H "Accept: application/json" \
 -H "Content-Type: application/json" \
 "https://api.domainflow.dev/api/v2/proxies/bulk/delete" \
 -d '{
  "proxyIds" : [ "046b6c7f-0b8a-43b9-b35d-6489e6daee91", "046b6c7f-0b8a-43b9-b35d-6489e6daee91" ]
}'
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.ProxiesApi;

import java.io.File;
import java.util.*;

public class ProxiesApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure API key authorization: cookieAuth
        ApiKeyAuth cookieAuth = (ApiKeyAuth) defaultClient.getAuthentication("cookieAuth");
        cookieAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //cookieAuth.setApiKeyPrefix("Token");

        // Create an instance of the API class
        ProxiesApi apiInstance = new ProxiesApi();
        BulkDeleteProxiesRequest bulkDeleteProxiesRequest = ; // BulkDeleteProxiesRequest | 

        try {
            proxies_bulk_update_200_response result = apiInstance.proxiesBulkDelete(bulkDeleteProxiesRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ProxiesApi#proxiesBulkDelete");
            e.printStackTrace();
        }
    }
}
import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final BulkDeleteProxiesRequest bulkDeleteProxiesRequest = new BulkDeleteProxiesRequest(); // BulkDeleteProxiesRequest | 

try {
    final result = await api_instance.proxiesBulkDelete(bulkDeleteProxiesRequest);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->proxiesBulkDelete: $e\n');
}

import org.openapitools.client.api.ProxiesApi;

public class ProxiesApiExample {
    public static void main(String[] args) {
        ProxiesApi apiInstance = new ProxiesApi();
        BulkDeleteProxiesRequest bulkDeleteProxiesRequest = ; // BulkDeleteProxiesRequest | 

        try {
            proxies_bulk_update_200_response result = apiInstance.proxiesBulkDelete(bulkDeleteProxiesRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ProxiesApi#proxiesBulkDelete");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: cookieAuth)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"domainflow_session"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"domainflow_session"];


// Create an instance of the API class
ProxiesApi *apiInstance = [[ProxiesApi alloc] init];
BulkDeleteProxiesRequest *bulkDeleteProxiesRequest = ; // 

// Bulk delete proxies
[apiInstance proxiesBulkDeleteWith:bulkDeleteProxiesRequest
              completionHandler: ^(proxies_bulk_update_200_response output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var DomainFlowApi = require('domain_flow_api');
var defaultClient = DomainFlowApi.ApiClient.instance;

// Configure API key authorization: cookieAuth
var cookieAuth = defaultClient.authentications['cookieAuth'];
cookieAuth.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//cookieAuth.apiKeyPrefix['domainflow_session'] = "Token";

// Create an instance of the API class
var api = new DomainFlowApi.ProxiesApi()
var bulkDeleteProxiesRequest = ; // {BulkDeleteProxiesRequest} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.proxiesBulkDelete(bulkDeleteProxiesRequest, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class proxiesBulkDeleteExample
    {
        public void main()
        {
            // Configure API key authorization: cookieAuth
            Configuration.Default.ApiKey.Add("domainflow_session", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("domainflow_session", "Bearer");

            // Create an instance of the API class
            var apiInstance = new ProxiesApi();
            var bulkDeleteProxiesRequest = new BulkDeleteProxiesRequest(); // BulkDeleteProxiesRequest | 

            try {
                // Bulk delete proxies
                proxies_bulk_update_200_response result = apiInstance.proxiesBulkDelete(bulkDeleteProxiesRequest);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling ProxiesApi.proxiesBulkDelete: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure API key authorization: cookieAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('domainflow_session', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('domainflow_session', 'Bearer');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\ProxiesApi();
$bulkDeleteProxiesRequest = ; // BulkDeleteProxiesRequest | 

try {
    $result = $api_instance->proxiesBulkDelete($bulkDeleteProxiesRequest);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling ProxiesApi->proxiesBulkDelete: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::ProxiesApi;

# Configure API key authorization: cookieAuth
$WWW::OPenAPIClient::Configuration::api_key->{'domainflow_session'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'domainflow_session'} = "Bearer";

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::ProxiesApi->new();
my $bulkDeleteProxiesRequest = WWW::OPenAPIClient::Object::BulkDeleteProxiesRequest->new(); # BulkDeleteProxiesRequest | 

eval {
    my $result = $api_instance->proxiesBulkDelete(bulkDeleteProxiesRequest => $bulkDeleteProxiesRequest);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling ProxiesApi->proxiesBulkDelete: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure API key authorization: cookieAuth
openapi_client.configuration.api_key['domainflow_session'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['domainflow_session'] = 'Bearer'

# Create an instance of the API class
api_instance = openapi_client.ProxiesApi()
bulkDeleteProxiesRequest =  # BulkDeleteProxiesRequest | 

try:
    # Bulk delete proxies
    api_response = api_instance.proxies_bulk_delete(bulkDeleteProxiesRequest)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ProxiesApi->proxiesBulkDelete: %s\n" % e)
extern crate ProxiesApi;

pub fn main() {
    let bulkDeleteProxiesRequest = ; // BulkDeleteProxiesRequest

    let mut context = ProxiesApi::Context::default();
    let result = client.proxiesBulkDelete(bulkDeleteProxiesRequest, &context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Body parameters
Name Description
bulkDeleteProxiesRequest *

Responses


proxiesBulkTest

Bulk test proxies


/proxies/bulk/test

Usage and SDK Samples

curl -X POST \
 \
 -H "Accept: application/json" \
 -H "Content-Type: application/json" \
 "https://api.domainflow.dev/api/v2/proxies/bulk/test" \
 -d ''
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.ProxiesApi;

import java.io.File;
import java.util.*;

public class ProxiesApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure API key authorization: cookieAuth
        ApiKeyAuth cookieAuth = (ApiKeyAuth) defaultClient.getAuthentication("cookieAuth");
        cookieAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //cookieAuth.setApiKeyPrefix("Token");

        // Create an instance of the API class
        ProxiesApi apiInstance = new ProxiesApi();
        ProxiesBulkTestRequest proxiesBulkTestRequest = ; // ProxiesBulkTestRequest | 

        try {
            proxies_bulk_test_200_response result = apiInstance.proxiesBulkTest(proxiesBulkTestRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ProxiesApi#proxiesBulkTest");
            e.printStackTrace();
        }
    }
}
import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final ProxiesBulkTestRequest proxiesBulkTestRequest = new ProxiesBulkTestRequest(); // ProxiesBulkTestRequest | 

try {
    final result = await api_instance.proxiesBulkTest(proxiesBulkTestRequest);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->proxiesBulkTest: $e\n');
}

import org.openapitools.client.api.ProxiesApi;

public class ProxiesApiExample {
    public static void main(String[] args) {
        ProxiesApi apiInstance = new ProxiesApi();
        ProxiesBulkTestRequest proxiesBulkTestRequest = ; // ProxiesBulkTestRequest | 

        try {
            proxies_bulk_test_200_response result = apiInstance.proxiesBulkTest(proxiesBulkTestRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ProxiesApi#proxiesBulkTest");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: cookieAuth)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"domainflow_session"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"domainflow_session"];


// Create an instance of the API class
ProxiesApi *apiInstance = [[ProxiesApi alloc] init];
ProxiesBulkTestRequest *proxiesBulkTestRequest = ; // 

// Bulk test proxies
[apiInstance proxiesBulkTestWith:proxiesBulkTestRequest
              completionHandler: ^(proxies_bulk_test_200_response output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var DomainFlowApi = require('domain_flow_api');
var defaultClient = DomainFlowApi.ApiClient.instance;

// Configure API key authorization: cookieAuth
var cookieAuth = defaultClient.authentications['cookieAuth'];
cookieAuth.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//cookieAuth.apiKeyPrefix['domainflow_session'] = "Token";

// Create an instance of the API class
var api = new DomainFlowApi.ProxiesApi()
var proxiesBulkTestRequest = ; // {ProxiesBulkTestRequest} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.proxiesBulkTest(proxiesBulkTestRequest, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class proxiesBulkTestExample
    {
        public void main()
        {
            // Configure API key authorization: cookieAuth
            Configuration.Default.ApiKey.Add("domainflow_session", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("domainflow_session", "Bearer");

            // Create an instance of the API class
            var apiInstance = new ProxiesApi();
            var proxiesBulkTestRequest = new ProxiesBulkTestRequest(); // ProxiesBulkTestRequest | 

            try {
                // Bulk test proxies
                proxies_bulk_test_200_response result = apiInstance.proxiesBulkTest(proxiesBulkTestRequest);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling ProxiesApi.proxiesBulkTest: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure API key authorization: cookieAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('domainflow_session', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('domainflow_session', 'Bearer');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\ProxiesApi();
$proxiesBulkTestRequest = ; // ProxiesBulkTestRequest | 

try {
    $result = $api_instance->proxiesBulkTest($proxiesBulkTestRequest);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling ProxiesApi->proxiesBulkTest: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::ProxiesApi;

# Configure API key authorization: cookieAuth
$WWW::OPenAPIClient::Configuration::api_key->{'domainflow_session'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'domainflow_session'} = "Bearer";

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::ProxiesApi->new();
my $proxiesBulkTestRequest = WWW::OPenAPIClient::Object::ProxiesBulkTestRequest->new(); # ProxiesBulkTestRequest | 

eval {
    my $result = $api_instance->proxiesBulkTest(proxiesBulkTestRequest => $proxiesBulkTestRequest);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling ProxiesApi->proxiesBulkTest: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure API key authorization: cookieAuth
openapi_client.configuration.api_key['domainflow_session'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['domainflow_session'] = 'Bearer'

# Create an instance of the API class
api_instance = openapi_client.ProxiesApi()
proxiesBulkTestRequest =  # ProxiesBulkTestRequest | 

try:
    # Bulk test proxies
    api_response = api_instance.proxies_bulk_test(proxiesBulkTestRequest)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ProxiesApi->proxiesBulkTest: %s\n" % e)
extern crate ProxiesApi;

pub fn main() {
    let proxiesBulkTestRequest = ; // ProxiesBulkTestRequest

    let mut context = ProxiesApi::Context::default();
    let result = client.proxiesBulkTest(proxiesBulkTestRequest, &context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Body parameters
Name Description
proxiesBulkTestRequest *

Responses


proxiesBulkUpdate

Bulk update proxies


/proxies/bulk/update

Usage and SDK Samples

curl -X PUT \
 \
 -H "Accept: application/json" \
 -H "Content-Type: application/json" \
 "https://api.domainflow.dev/api/v2/proxies/bulk/update" \
 -d '{
  "updates" : {
    "protocol" : "http",
    "password" : "password",
    "address" : "address",
    "notes" : "notes",
    "countryCode" : "countryCode",
    "isEnabled" : true,
    "name" : "name",
    "description" : "description",
    "username" : "username"
  },
  "proxyIds" : [ "046b6c7f-0b8a-43b9-b35d-6489e6daee91", "046b6c7f-0b8a-43b9-b35d-6489e6daee91" ]
}'
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.ProxiesApi;

import java.io.File;
import java.util.*;

public class ProxiesApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure API key authorization: cookieAuth
        ApiKeyAuth cookieAuth = (ApiKeyAuth) defaultClient.getAuthentication("cookieAuth");
        cookieAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //cookieAuth.setApiKeyPrefix("Token");

        // Create an instance of the API class
        ProxiesApi apiInstance = new ProxiesApi();
        BulkUpdateProxiesRequest bulkUpdateProxiesRequest = ; // BulkUpdateProxiesRequest | 

        try {
            proxies_bulk_update_200_response result = apiInstance.proxiesBulkUpdate(bulkUpdateProxiesRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ProxiesApi#proxiesBulkUpdate");
            e.printStackTrace();
        }
    }
}
import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final BulkUpdateProxiesRequest bulkUpdateProxiesRequest = new BulkUpdateProxiesRequest(); // BulkUpdateProxiesRequest | 

try {
    final result = await api_instance.proxiesBulkUpdate(bulkUpdateProxiesRequest);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->proxiesBulkUpdate: $e\n');
}

import org.openapitools.client.api.ProxiesApi;

public class ProxiesApiExample {
    public static void main(String[] args) {
        ProxiesApi apiInstance = new ProxiesApi();
        BulkUpdateProxiesRequest bulkUpdateProxiesRequest = ; // BulkUpdateProxiesRequest | 

        try {
            proxies_bulk_update_200_response result = apiInstance.proxiesBulkUpdate(bulkUpdateProxiesRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ProxiesApi#proxiesBulkUpdate");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: cookieAuth)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"domainflow_session"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"domainflow_session"];


// Create an instance of the API class
ProxiesApi *apiInstance = [[ProxiesApi alloc] init];
BulkUpdateProxiesRequest *bulkUpdateProxiesRequest = ; // 

// Bulk update proxies
[apiInstance proxiesBulkUpdateWith:bulkUpdateProxiesRequest
              completionHandler: ^(proxies_bulk_update_200_response output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var DomainFlowApi = require('domain_flow_api');
var defaultClient = DomainFlowApi.ApiClient.instance;

// Configure API key authorization: cookieAuth
var cookieAuth = defaultClient.authentications['cookieAuth'];
cookieAuth.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//cookieAuth.apiKeyPrefix['domainflow_session'] = "Token";

// Create an instance of the API class
var api = new DomainFlowApi.ProxiesApi()
var bulkUpdateProxiesRequest = ; // {BulkUpdateProxiesRequest} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.proxiesBulkUpdate(bulkUpdateProxiesRequest, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class proxiesBulkUpdateExample
    {
        public void main()
        {
            // Configure API key authorization: cookieAuth
            Configuration.Default.ApiKey.Add("domainflow_session", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("domainflow_session", "Bearer");

            // Create an instance of the API class
            var apiInstance = new ProxiesApi();
            var bulkUpdateProxiesRequest = new BulkUpdateProxiesRequest(); // BulkUpdateProxiesRequest | 

            try {
                // Bulk update proxies
                proxies_bulk_update_200_response result = apiInstance.proxiesBulkUpdate(bulkUpdateProxiesRequest);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling ProxiesApi.proxiesBulkUpdate: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure API key authorization: cookieAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('domainflow_session', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('domainflow_session', 'Bearer');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\ProxiesApi();
$bulkUpdateProxiesRequest = ; // BulkUpdateProxiesRequest | 

try {
    $result = $api_instance->proxiesBulkUpdate($bulkUpdateProxiesRequest);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling ProxiesApi->proxiesBulkUpdate: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::ProxiesApi;

# Configure API key authorization: cookieAuth
$WWW::OPenAPIClient::Configuration::api_key->{'domainflow_session'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'domainflow_session'} = "Bearer";

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::ProxiesApi->new();
my $bulkUpdateProxiesRequest = WWW::OPenAPIClient::Object::BulkUpdateProxiesRequest->new(); # BulkUpdateProxiesRequest | 

eval {
    my $result = $api_instance->proxiesBulkUpdate(bulkUpdateProxiesRequest => $bulkUpdateProxiesRequest);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling ProxiesApi->proxiesBulkUpdate: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure API key authorization: cookieAuth
openapi_client.configuration.api_key['domainflow_session'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['domainflow_session'] = 'Bearer'

# Create an instance of the API class
api_instance = openapi_client.ProxiesApi()
bulkUpdateProxiesRequest =  # BulkUpdateProxiesRequest | 

try:
    # Bulk update proxies
    api_response = api_instance.proxies_bulk_update(bulkUpdateProxiesRequest)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ProxiesApi->proxiesBulkUpdate: %s\n" % e)
extern crate ProxiesApi;

pub fn main() {
    let bulkUpdateProxiesRequest = ; // BulkUpdateProxiesRequest

    let mut context = ProxiesApi::Context::default();
    let result = client.proxiesBulkUpdate(bulkUpdateProxiesRequest, &context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Body parameters
Name Description
bulkUpdateProxiesRequest *

Responses


proxiesCreate

Create proxy


/proxies

Usage and SDK Samples

curl -X POST \
 \
 -H "Accept: application/json" \
 -H "Content-Type: application/json" \
 "https://api.domainflow.dev/api/v2/proxies" \
 -d '{
  "protocol" : "http",
  "password" : "password",
  "address" : "address",
  "notes" : "notes",
  "countryCode" : "countryCode",
  "isEnabled" : true,
  "name" : "name",
  "description" : "description",
  "username" : "username"
}'
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.ProxiesApi;

import java.io.File;
import java.util.*;

public class ProxiesApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure API key authorization: cookieAuth
        ApiKeyAuth cookieAuth = (ApiKeyAuth) defaultClient.getAuthentication("cookieAuth");
        cookieAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //cookieAuth.setApiKeyPrefix("Token");

        // Create an instance of the API class
        ProxiesApi apiInstance = new ProxiesApi();
        CreateProxyRequestAPI createProxyRequestAPI = ; // CreateProxyRequestAPI | 

        try {
            proxies_create_201_response result = apiInstance.proxiesCreate(createProxyRequestAPI);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ProxiesApi#proxiesCreate");
            e.printStackTrace();
        }
    }
}
import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final CreateProxyRequestAPI createProxyRequestAPI = new CreateProxyRequestAPI(); // CreateProxyRequestAPI | 

try {
    final result = await api_instance.proxiesCreate(createProxyRequestAPI);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->proxiesCreate: $e\n');
}

import org.openapitools.client.api.ProxiesApi;

public class ProxiesApiExample {
    public static void main(String[] args) {
        ProxiesApi apiInstance = new ProxiesApi();
        CreateProxyRequestAPI createProxyRequestAPI = ; // CreateProxyRequestAPI | 

        try {
            proxies_create_201_response result = apiInstance.proxiesCreate(createProxyRequestAPI);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ProxiesApi#proxiesCreate");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: cookieAuth)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"domainflow_session"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"domainflow_session"];


// Create an instance of the API class
ProxiesApi *apiInstance = [[ProxiesApi alloc] init];
CreateProxyRequestAPI *createProxyRequestAPI = ; // 

// Create proxy
[apiInstance proxiesCreateWith:createProxyRequestAPI
              completionHandler: ^(proxies_create_201_response output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var DomainFlowApi = require('domain_flow_api');
var defaultClient = DomainFlowApi.ApiClient.instance;

// Configure API key authorization: cookieAuth
var cookieAuth = defaultClient.authentications['cookieAuth'];
cookieAuth.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//cookieAuth.apiKeyPrefix['domainflow_session'] = "Token";

// Create an instance of the API class
var api = new DomainFlowApi.ProxiesApi()
var createProxyRequestAPI = ; // {CreateProxyRequestAPI} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.proxiesCreate(createProxyRequestAPI, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class proxiesCreateExample
    {
        public void main()
        {
            // Configure API key authorization: cookieAuth
            Configuration.Default.ApiKey.Add("domainflow_session", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("domainflow_session", "Bearer");

            // Create an instance of the API class
            var apiInstance = new ProxiesApi();
            var createProxyRequestAPI = new CreateProxyRequestAPI(); // CreateProxyRequestAPI | 

            try {
                // Create proxy
                proxies_create_201_response result = apiInstance.proxiesCreate(createProxyRequestAPI);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling ProxiesApi.proxiesCreate: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure API key authorization: cookieAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('domainflow_session', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('domainflow_session', 'Bearer');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\ProxiesApi();
$createProxyRequestAPI = ; // CreateProxyRequestAPI | 

try {
    $result = $api_instance->proxiesCreate($createProxyRequestAPI);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling ProxiesApi->proxiesCreate: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::ProxiesApi;

# Configure API key authorization: cookieAuth
$WWW::OPenAPIClient::Configuration::api_key->{'domainflow_session'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'domainflow_session'} = "Bearer";

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::ProxiesApi->new();
my $createProxyRequestAPI = WWW::OPenAPIClient::Object::CreateProxyRequestAPI->new(); # CreateProxyRequestAPI | 

eval {
    my $result = $api_instance->proxiesCreate(createProxyRequestAPI => $createProxyRequestAPI);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling ProxiesApi->proxiesCreate: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure API key authorization: cookieAuth
openapi_client.configuration.api_key['domainflow_session'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['domainflow_session'] = 'Bearer'

# Create an instance of the API class
api_instance = openapi_client.ProxiesApi()
createProxyRequestAPI =  # CreateProxyRequestAPI | 

try:
    # Create proxy
    api_response = api_instance.proxies_create(createProxyRequestAPI)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ProxiesApi->proxiesCreate: %s\n" % e)
extern crate ProxiesApi;

pub fn main() {
    let createProxyRequestAPI = ; // CreateProxyRequestAPI

    let mut context = ProxiesApi::Context::default();
    let result = client.proxiesCreate(createProxyRequestAPI, &context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Body parameters
Name Description
createProxyRequestAPI *

Responses

Name Type Format Description
Retry-After Integer Seconds to wait before retrying


proxiesDelete

Delete proxy


/proxies/{proxyId}

Usage and SDK Samples

curl -X DELETE \
 \
 -H "Accept: application/json" \
 "https://api.domainflow.dev/api/v2/proxies/{proxyId}"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.ProxiesApi;

import java.io.File;
import java.util.*;

public class ProxiesApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure API key authorization: cookieAuth
        ApiKeyAuth cookieAuth = (ApiKeyAuth) defaultClient.getAuthentication("cookieAuth");
        cookieAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //cookieAuth.setApiKeyPrefix("Token");

        // Create an instance of the API class
        ProxiesApi apiInstance = new ProxiesApi();
        UUID proxyId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 

        try {
            SuccessEnvelope result = apiInstance.proxiesDelete(proxyId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ProxiesApi#proxiesDelete");
            e.printStackTrace();
        }
    }
}
import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final UUID proxyId = new UUID(); // UUID | 

try {
    final result = await api_instance.proxiesDelete(proxyId);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->proxiesDelete: $e\n');
}

import org.openapitools.client.api.ProxiesApi;

public class ProxiesApiExample {
    public static void main(String[] args) {
        ProxiesApi apiInstance = new ProxiesApi();
        UUID proxyId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 

        try {
            SuccessEnvelope result = apiInstance.proxiesDelete(proxyId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ProxiesApi#proxiesDelete");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: cookieAuth)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"domainflow_session"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"domainflow_session"];


// Create an instance of the API class
ProxiesApi *apiInstance = [[ProxiesApi alloc] init];
UUID *proxyId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; //  (default to null)

// Delete proxy
[apiInstance proxiesDeleteWith:proxyId
              completionHandler: ^(SuccessEnvelope output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var DomainFlowApi = require('domain_flow_api');
var defaultClient = DomainFlowApi.ApiClient.instance;

// Configure API key authorization: cookieAuth
var cookieAuth = defaultClient.authentications['cookieAuth'];
cookieAuth.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//cookieAuth.apiKeyPrefix['domainflow_session'] = "Token";

// Create an instance of the API class
var api = new DomainFlowApi.ProxiesApi()
var proxyId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // {UUID} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.proxiesDelete(proxyId, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class proxiesDeleteExample
    {
        public void main()
        {
            // Configure API key authorization: cookieAuth
            Configuration.Default.ApiKey.Add("domainflow_session", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("domainflow_session", "Bearer");

            // Create an instance of the API class
            var apiInstance = new ProxiesApi();
            var proxyId = 38400000-8cf0-11bd-b23e-10b96e4ef00d;  // UUID |  (default to null)

            try {
                // Delete proxy
                SuccessEnvelope result = apiInstance.proxiesDelete(proxyId);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling ProxiesApi.proxiesDelete: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure API key authorization: cookieAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('domainflow_session', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('domainflow_session', 'Bearer');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\ProxiesApi();
$proxyId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 

try {
    $result = $api_instance->proxiesDelete($proxyId);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling ProxiesApi->proxiesDelete: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::ProxiesApi;

# Configure API key authorization: cookieAuth
$WWW::OPenAPIClient::Configuration::api_key->{'domainflow_session'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'domainflow_session'} = "Bearer";

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::ProxiesApi->new();
my $proxyId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; # UUID | 

eval {
    my $result = $api_instance->proxiesDelete(proxyId => $proxyId);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling ProxiesApi->proxiesDelete: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure API key authorization: cookieAuth
openapi_client.configuration.api_key['domainflow_session'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['domainflow_session'] = 'Bearer'

# Create an instance of the API class
api_instance = openapi_client.ProxiesApi()
proxyId = 38400000-8cf0-11bd-b23e-10b96e4ef00d # UUID |  (default to null)

try:
    # Delete proxy
    api_response = api_instance.proxies_delete(proxyId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ProxiesApi->proxiesDelete: %s\n" % e)
extern crate ProxiesApi;

pub fn main() {
    let proxyId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID

    let mut context = ProxiesApi::Context::default();
    let result = client.proxiesDelete(proxyId, &context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Path parameters
Name Description
proxyId*
UUID (uuid)
Required

Responses


proxiesHealthCheckAll

Health check all proxies


/proxies/health-check

Usage and SDK Samples

curl -X POST \
 \
 -H "Accept: application/json" \
 -H "Content-Type: application/json" \
 "https://api.domainflow.dev/api/v2/proxies/health-check" \
 -d ''
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.ProxiesApi;

import java.io.File;
import java.util.*;

public class ProxiesApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure API key authorization: cookieAuth
        ApiKeyAuth cookieAuth = (ApiKeyAuth) defaultClient.getAuthentication("cookieAuth");
        cookieAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //cookieAuth.setApiKeyPrefix("Token");

        // Create an instance of the API class
        ProxiesApi apiInstance = new ProxiesApi();
        ProxiesHealthCheckAllRequest proxiesHealthCheckAllRequest = ; // ProxiesHealthCheckAllRequest | 

        try {
            proxies_health_check_all_202_response result = apiInstance.proxiesHealthCheckAll(proxiesHealthCheckAllRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ProxiesApi#proxiesHealthCheckAll");
            e.printStackTrace();
        }
    }
}
import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final ProxiesHealthCheckAllRequest proxiesHealthCheckAllRequest = new ProxiesHealthCheckAllRequest(); // ProxiesHealthCheckAllRequest | 

try {
    final result = await api_instance.proxiesHealthCheckAll(proxiesHealthCheckAllRequest);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->proxiesHealthCheckAll: $e\n');
}

import org.openapitools.client.api.ProxiesApi;

public class ProxiesApiExample {
    public static void main(String[] args) {
        ProxiesApi apiInstance = new ProxiesApi();
        ProxiesHealthCheckAllRequest proxiesHealthCheckAllRequest = ; // ProxiesHealthCheckAllRequest | 

        try {
            proxies_health_check_all_202_response result = apiInstance.proxiesHealthCheckAll(proxiesHealthCheckAllRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ProxiesApi#proxiesHealthCheckAll");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: cookieAuth)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"domainflow_session"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"domainflow_session"];


// Create an instance of the API class
ProxiesApi *apiInstance = [[ProxiesApi alloc] init];
ProxiesHealthCheckAllRequest *proxiesHealthCheckAllRequest = ; //  (optional)

// Health check all proxies
[apiInstance proxiesHealthCheckAllWith:proxiesHealthCheckAllRequest
              completionHandler: ^(proxies_health_check_all_202_response output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var DomainFlowApi = require('domain_flow_api');
var defaultClient = DomainFlowApi.ApiClient.instance;

// Configure API key authorization: cookieAuth
var cookieAuth = defaultClient.authentications['cookieAuth'];
cookieAuth.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//cookieAuth.apiKeyPrefix['domainflow_session'] = "Token";

// Create an instance of the API class
var api = new DomainFlowApi.ProxiesApi()
var opts = {
  'proxiesHealthCheckAllRequest':  // {ProxiesHealthCheckAllRequest} 
};

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.proxiesHealthCheckAll(opts, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class proxiesHealthCheckAllExample
    {
        public void main()
        {
            // Configure API key authorization: cookieAuth
            Configuration.Default.ApiKey.Add("domainflow_session", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("domainflow_session", "Bearer");

            // Create an instance of the API class
            var apiInstance = new ProxiesApi();
            var proxiesHealthCheckAllRequest = new ProxiesHealthCheckAllRequest(); // ProxiesHealthCheckAllRequest |  (optional) 

            try {
                // Health check all proxies
                proxies_health_check_all_202_response result = apiInstance.proxiesHealthCheckAll(proxiesHealthCheckAllRequest);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling ProxiesApi.proxiesHealthCheckAll: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure API key authorization: cookieAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('domainflow_session', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('domainflow_session', 'Bearer');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\ProxiesApi();
$proxiesHealthCheckAllRequest = ; // ProxiesHealthCheckAllRequest | 

try {
    $result = $api_instance->proxiesHealthCheckAll($proxiesHealthCheckAllRequest);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling ProxiesApi->proxiesHealthCheckAll: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::ProxiesApi;

# Configure API key authorization: cookieAuth
$WWW::OPenAPIClient::Configuration::api_key->{'domainflow_session'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'domainflow_session'} = "Bearer";

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::ProxiesApi->new();
my $proxiesHealthCheckAllRequest = WWW::OPenAPIClient::Object::ProxiesHealthCheckAllRequest->new(); # ProxiesHealthCheckAllRequest | 

eval {
    my $result = $api_instance->proxiesHealthCheckAll(proxiesHealthCheckAllRequest => $proxiesHealthCheckAllRequest);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling ProxiesApi->proxiesHealthCheckAll: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure API key authorization: cookieAuth
openapi_client.configuration.api_key['domainflow_session'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['domainflow_session'] = 'Bearer'

# Create an instance of the API class
api_instance = openapi_client.ProxiesApi()
proxiesHealthCheckAllRequest =  # ProxiesHealthCheckAllRequest |  (optional)

try:
    # Health check all proxies
    api_response = api_instance.proxies_health_check_all(proxiesHealthCheckAllRequest=proxiesHealthCheckAllRequest)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ProxiesApi->proxiesHealthCheckAll: %s\n" % e)
extern crate ProxiesApi;

pub fn main() {
    let proxiesHealthCheckAllRequest = ; // ProxiesHealthCheckAllRequest

    let mut context = ProxiesApi::Context::default();
    let result = client.proxiesHealthCheckAll(proxiesHealthCheckAllRequest, &context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Body parameters
Name Description
proxiesHealthCheckAllRequest

Responses


proxiesHealthCheckSingle

Health check single proxy


/proxies/{proxyId}/health-check

Usage and SDK Samples

curl -X POST \
 \
 -H "Accept: application/json" \
 "https://api.domainflow.dev/api/v2/proxies/{proxyId}/health-check"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.ProxiesApi;

import java.io.File;
import java.util.*;

public class ProxiesApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure API key authorization: cookieAuth
        ApiKeyAuth cookieAuth = (ApiKeyAuth) defaultClient.getAuthentication("cookieAuth");
        cookieAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //cookieAuth.setApiKeyPrefix("Token");

        // Create an instance of the API class
        ProxiesApi apiInstance = new ProxiesApi();
        UUID proxyId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 

        try {
            proxies_health_check_single_200_response result = apiInstance.proxiesHealthCheckSingle(proxyId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ProxiesApi#proxiesHealthCheckSingle");
            e.printStackTrace();
        }
    }
}
import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final UUID proxyId = new UUID(); // UUID | 

try {
    final result = await api_instance.proxiesHealthCheckSingle(proxyId);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->proxiesHealthCheckSingle: $e\n');
}

import org.openapitools.client.api.ProxiesApi;

public class ProxiesApiExample {
    public static void main(String[] args) {
        ProxiesApi apiInstance = new ProxiesApi();
        UUID proxyId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 

        try {
            proxies_health_check_single_200_response result = apiInstance.proxiesHealthCheckSingle(proxyId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ProxiesApi#proxiesHealthCheckSingle");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: cookieAuth)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"domainflow_session"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"domainflow_session"];


// Create an instance of the API class
ProxiesApi *apiInstance = [[ProxiesApi alloc] init];
UUID *proxyId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; //  (default to null)

// Health check single proxy
[apiInstance proxiesHealthCheckSingleWith:proxyId
              completionHandler: ^(proxies_health_check_single_200_response output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var DomainFlowApi = require('domain_flow_api');
var defaultClient = DomainFlowApi.ApiClient.instance;

// Configure API key authorization: cookieAuth
var cookieAuth = defaultClient.authentications['cookieAuth'];
cookieAuth.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//cookieAuth.apiKeyPrefix['domainflow_session'] = "Token";

// Create an instance of the API class
var api = new DomainFlowApi.ProxiesApi()
var proxyId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // {UUID} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.proxiesHealthCheckSingle(proxyId, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class proxiesHealthCheckSingleExample
    {
        public void main()
        {
            // Configure API key authorization: cookieAuth
            Configuration.Default.ApiKey.Add("domainflow_session", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("domainflow_session", "Bearer");

            // Create an instance of the API class
            var apiInstance = new ProxiesApi();
            var proxyId = 38400000-8cf0-11bd-b23e-10b96e4ef00d;  // UUID |  (default to null)

            try {
                // Health check single proxy
                proxies_health_check_single_200_response result = apiInstance.proxiesHealthCheckSingle(proxyId);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling ProxiesApi.proxiesHealthCheckSingle: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure API key authorization: cookieAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('domainflow_session', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('domainflow_session', 'Bearer');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\ProxiesApi();
$proxyId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 

try {
    $result = $api_instance->proxiesHealthCheckSingle($proxyId);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling ProxiesApi->proxiesHealthCheckSingle: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::ProxiesApi;

# Configure API key authorization: cookieAuth
$WWW::OPenAPIClient::Configuration::api_key->{'domainflow_session'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'domainflow_session'} = "Bearer";

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::ProxiesApi->new();
my $proxyId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; # UUID | 

eval {
    my $result = $api_instance->proxiesHealthCheckSingle(proxyId => $proxyId);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling ProxiesApi->proxiesHealthCheckSingle: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure API key authorization: cookieAuth
openapi_client.configuration.api_key['domainflow_session'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['domainflow_session'] = 'Bearer'

# Create an instance of the API class
api_instance = openapi_client.ProxiesApi()
proxyId = 38400000-8cf0-11bd-b23e-10b96e4ef00d # UUID |  (default to null)

try:
    # Health check single proxy
    api_response = api_instance.proxies_health_check_single(proxyId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ProxiesApi->proxiesHealthCheckSingle: %s\n" % e)
extern crate ProxiesApi;

pub fn main() {
    let proxyId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID

    let mut context = ProxiesApi::Context::default();
    let result = client.proxiesHealthCheckSingle(proxyId, &context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Path parameters
Name Description
proxyId*
UUID (uuid)
Required

Responses


proxiesList

List proxies


/proxies

Usage and SDK Samples

curl -X GET \
 \
 -H "Accept: application/json" \
 "https://api.domainflow.dev/api/v2/proxies?limit=56&offset=56&protocol=&countryCode=countryCode_example&isEnabled=true&isHealthy=true"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.ProxiesApi;

import java.io.File;
import java.util.*;

public class ProxiesApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure API key authorization: cookieAuth
        ApiKeyAuth cookieAuth = (ApiKeyAuth) defaultClient.getAuthentication("cookieAuth");
        cookieAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //cookieAuth.setApiKeyPrefix("Token");

        // Create an instance of the API class
        ProxiesApi apiInstance = new ProxiesApi();
        Integer limit = 56; // Integer | Page size (items per page)
        Integer offset = 56; // Integer | Zero-based offset
        ProxyProtocol protocol = ; // ProxyProtocol | Filter proxies by protocol
        String countryCode = countryCode_example; // String | Filter proxies by ISO country code
        Boolean isEnabled = true; // Boolean | Filter by enabled state
        Boolean isHealthy = true; // Boolean | Filter by health status

        try {
            proxies_list_200_response result = apiInstance.proxiesList(limit, offset, protocol, countryCode, isEnabled, isHealthy);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ProxiesApi#proxiesList");
            e.printStackTrace();
        }
    }
}
import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final Integer limit = new Integer(); // Integer | Page size (items per page)
final Integer offset = new Integer(); // Integer | Zero-based offset
final ProxyProtocol protocol = new ProxyProtocol(); // ProxyProtocol | Filter proxies by protocol
final String countryCode = new String(); // String | Filter proxies by ISO country code
final Boolean isEnabled = new Boolean(); // Boolean | Filter by enabled state
final Boolean isHealthy = new Boolean(); // Boolean | Filter by health status

try {
    final result = await api_instance.proxiesList(limit, offset, protocol, countryCode, isEnabled, isHealthy);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->proxiesList: $e\n');
}

import org.openapitools.client.api.ProxiesApi;

public class ProxiesApiExample {
    public static void main(String[] args) {
        ProxiesApi apiInstance = new ProxiesApi();
        Integer limit = 56; // Integer | Page size (items per page)
        Integer offset = 56; // Integer | Zero-based offset
        ProxyProtocol protocol = ; // ProxyProtocol | Filter proxies by protocol
        String countryCode = countryCode_example; // String | Filter proxies by ISO country code
        Boolean isEnabled = true; // Boolean | Filter by enabled state
        Boolean isHealthy = true; // Boolean | Filter by health status

        try {
            proxies_list_200_response result = apiInstance.proxiesList(limit, offset, protocol, countryCode, isEnabled, isHealthy);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ProxiesApi#proxiesList");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: cookieAuth)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"domainflow_session"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"domainflow_session"];


// Create an instance of the API class
ProxiesApi *apiInstance = [[ProxiesApi alloc] init];
Integer *limit = 56; // Page size (items per page) (optional) (default to 50)
Integer *offset = 56; // Zero-based offset (optional) (default to 0)
ProxyProtocol *protocol = ; // Filter proxies by protocol (optional) (default to null)
String *countryCode = countryCode_example; // Filter proxies by ISO country code (optional) (default to null)
Boolean *isEnabled = true; // Filter by enabled state (optional) (default to null)
Boolean *isHealthy = true; // Filter by health status (optional) (default to null)

// List proxies
[apiInstance proxiesListWith:limit
    offset:offset
    protocol:protocol
    countryCode:countryCode
    isEnabled:isEnabled
    isHealthy:isHealthy
              completionHandler: ^(proxies_list_200_response output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var DomainFlowApi = require('domain_flow_api');
var defaultClient = DomainFlowApi.ApiClient.instance;

// Configure API key authorization: cookieAuth
var cookieAuth = defaultClient.authentications['cookieAuth'];
cookieAuth.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//cookieAuth.apiKeyPrefix['domainflow_session'] = "Token";

// Create an instance of the API class
var api = new DomainFlowApi.ProxiesApi()
var opts = {
  'limit': 56, // {Integer} Page size (items per page)
  'offset': 56, // {Integer} Zero-based offset
  'protocol': , // {ProxyProtocol} Filter proxies by protocol
  'countryCode': countryCode_example, // {String} Filter proxies by ISO country code
  'isEnabled': true, // {Boolean} Filter by enabled state
  'isHealthy': true // {Boolean} Filter by health status
};

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.proxiesList(opts, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class proxiesListExample
    {
        public void main()
        {
            // Configure API key authorization: cookieAuth
            Configuration.Default.ApiKey.Add("domainflow_session", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("domainflow_session", "Bearer");

            // Create an instance of the API class
            var apiInstance = new ProxiesApi();
            var limit = 56;  // Integer | Page size (items per page) (optional)  (default to 50)
            var offset = 56;  // Integer | Zero-based offset (optional)  (default to 0)
            var protocol = new ProxyProtocol(); // ProxyProtocol | Filter proxies by protocol (optional)  (default to null)
            var countryCode = countryCode_example;  // String | Filter proxies by ISO country code (optional)  (default to null)
            var isEnabled = true;  // Boolean | Filter by enabled state (optional)  (default to null)
            var isHealthy = true;  // Boolean | Filter by health status (optional)  (default to null)

            try {
                // List proxies
                proxies_list_200_response result = apiInstance.proxiesList(limit, offset, protocol, countryCode, isEnabled, isHealthy);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling ProxiesApi.proxiesList: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure API key authorization: cookieAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('domainflow_session', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('domainflow_session', 'Bearer');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\ProxiesApi();
$limit = 56; // Integer | Page size (items per page)
$offset = 56; // Integer | Zero-based offset
$protocol = ; // ProxyProtocol | Filter proxies by protocol
$countryCode = countryCode_example; // String | Filter proxies by ISO country code
$isEnabled = true; // Boolean | Filter by enabled state
$isHealthy = true; // Boolean | Filter by health status

try {
    $result = $api_instance->proxiesList($limit, $offset, $protocol, $countryCode, $isEnabled, $isHealthy);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling ProxiesApi->proxiesList: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::ProxiesApi;

# Configure API key authorization: cookieAuth
$WWW::OPenAPIClient::Configuration::api_key->{'domainflow_session'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'domainflow_session'} = "Bearer";

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::ProxiesApi->new();
my $limit = 56; # Integer | Page size (items per page)
my $offset = 56; # Integer | Zero-based offset
my $protocol = ; # ProxyProtocol | Filter proxies by protocol
my $countryCode = countryCode_example; # String | Filter proxies by ISO country code
my $isEnabled = true; # Boolean | Filter by enabled state
my $isHealthy = true; # Boolean | Filter by health status

eval {
    my $result = $api_instance->proxiesList(limit => $limit, offset => $offset, protocol => $protocol, countryCode => $countryCode, isEnabled => $isEnabled, isHealthy => $isHealthy);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling ProxiesApi->proxiesList: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure API key authorization: cookieAuth
openapi_client.configuration.api_key['domainflow_session'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['domainflow_session'] = 'Bearer'

# Create an instance of the API class
api_instance = openapi_client.ProxiesApi()
limit = 56 # Integer | Page size (items per page) (optional) (default to 50)
offset = 56 # Integer | Zero-based offset (optional) (default to 0)
protocol =  # ProxyProtocol | Filter proxies by protocol (optional) (default to null)
countryCode = countryCode_example # String | Filter proxies by ISO country code (optional) (default to null)
isEnabled = true # Boolean | Filter by enabled state (optional) (default to null)
isHealthy = true # Boolean | Filter by health status (optional) (default to null)

try:
    # List proxies
    api_response = api_instance.proxies_list(limit=limit, offset=offset, protocol=protocol, countryCode=countryCode, isEnabled=isEnabled, isHealthy=isHealthy)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ProxiesApi->proxiesList: %s\n" % e)
extern crate ProxiesApi;

pub fn main() {
    let limit = 56; // Integer
    let offset = 56; // Integer
    let protocol = ; // ProxyProtocol
    let countryCode = countryCode_example; // String
    let isEnabled = true; // Boolean
    let isHealthy = true; // Boolean

    let mut context = ProxiesApi::Context::default();
    let result = client.proxiesList(limit, offset, protocol, countryCode, isEnabled, isHealthy, &context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Query parameters
Name Description
limit
Integer
Page size (items per page)
offset
Integer
Zero-based offset
protocol
ProxyProtocol
Filter proxies by protocol
countryCode
String
Filter proxies by ISO country code
isEnabled
Boolean
Filter by enabled state
isHealthy
Boolean
Filter by health status

Responses

Name Type Format Description
Retry-After Integer Seconds to wait before retrying


proxiesStatus

Get proxy statuses


/proxies/status

Usage and SDK Samples

curl -X GET \
 \
 -H "Accept: application/json" \
 "https://api.domainflow.dev/api/v2/proxies/status"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.ProxiesApi;

import java.io.File;
import java.util.*;

public class ProxiesApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure API key authorization: cookieAuth
        ApiKeyAuth cookieAuth = (ApiKeyAuth) defaultClient.getAuthentication("cookieAuth");
        cookieAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //cookieAuth.setApiKeyPrefix("Token");

        // Create an instance of the API class
        ProxiesApi apiInstance = new ProxiesApi();

        try {
            proxies_status_200_response result = apiInstance.proxiesStatus();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ProxiesApi#proxiesStatus");
            e.printStackTrace();
        }
    }
}
import 'package:openapi/api.dart';

final api_instance = DefaultApi();


try {
    final result = await api_instance.proxiesStatus();
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->proxiesStatus: $e\n');
}

import org.openapitools.client.api.ProxiesApi;

public class ProxiesApiExample {
    public static void main(String[] args) {
        ProxiesApi apiInstance = new ProxiesApi();

        try {
            proxies_status_200_response result = apiInstance.proxiesStatus();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ProxiesApi#proxiesStatus");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: cookieAuth)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"domainflow_session"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"domainflow_session"];


// Create an instance of the API class
ProxiesApi *apiInstance = [[ProxiesApi alloc] init];

// Get proxy statuses
[apiInstance proxiesStatusWithCompletionHandler: 
              ^(proxies_status_200_response output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var DomainFlowApi = require('domain_flow_api');
var defaultClient = DomainFlowApi.ApiClient.instance;

// Configure API key authorization: cookieAuth
var cookieAuth = defaultClient.authentications['cookieAuth'];
cookieAuth.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//cookieAuth.apiKeyPrefix['domainflow_session'] = "Token";

// Create an instance of the API class
var api = new DomainFlowApi.ProxiesApi()
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.proxiesStatus(callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class proxiesStatusExample
    {
        public void main()
        {
            // Configure API key authorization: cookieAuth
            Configuration.Default.ApiKey.Add("domainflow_session", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("domainflow_session", "Bearer");

            // Create an instance of the API class
            var apiInstance = new ProxiesApi();

            try {
                // Get proxy statuses
                proxies_status_200_response result = apiInstance.proxiesStatus();
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling ProxiesApi.proxiesStatus: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure API key authorization: cookieAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('domainflow_session', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('domainflow_session', 'Bearer');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\ProxiesApi();

try {
    $result = $api_instance->proxiesStatus();
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling ProxiesApi->proxiesStatus: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::ProxiesApi;

# Configure API key authorization: cookieAuth
$WWW::OPenAPIClient::Configuration::api_key->{'domainflow_session'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'domainflow_session'} = "Bearer";

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::ProxiesApi->new();

eval {
    my $result = $api_instance->proxiesStatus();
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling ProxiesApi->proxiesStatus: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure API key authorization: cookieAuth
openapi_client.configuration.api_key['domainflow_session'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['domainflow_session'] = 'Bearer'

# Create an instance of the API class
api_instance = openapi_client.ProxiesApi()

try:
    # Get proxy statuses
    api_response = api_instance.proxies_status()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ProxiesApi->proxiesStatus: %s\n" % e)
extern crate ProxiesApi;

pub fn main() {

    let mut context = ProxiesApi::Context::default();
    let result = client.proxiesStatus(&context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Responses


proxiesTest

Test proxy


/proxies/{proxyId}/test

Usage and SDK Samples

curl -X POST \
 \
 -H "Accept: application/json" \
 "https://api.domainflow.dev/api/v2/proxies/{proxyId}/test"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.ProxiesApi;

import java.io.File;
import java.util.*;

public class ProxiesApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure API key authorization: cookieAuth
        ApiKeyAuth cookieAuth = (ApiKeyAuth) defaultClient.getAuthentication("cookieAuth");
        cookieAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //cookieAuth.setApiKeyPrefix("Token");

        // Create an instance of the API class
        ProxiesApi apiInstance = new ProxiesApi();
        UUID proxyId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 

        try {
            proxies_test_200_response result = apiInstance.proxiesTest(proxyId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ProxiesApi#proxiesTest");
            e.printStackTrace();
        }
    }
}
import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final UUID proxyId = new UUID(); // UUID | 

try {
    final result = await api_instance.proxiesTest(proxyId);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->proxiesTest: $e\n');
}

import org.openapitools.client.api.ProxiesApi;

public class ProxiesApiExample {
    public static void main(String[] args) {
        ProxiesApi apiInstance = new ProxiesApi();
        UUID proxyId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 

        try {
            proxies_test_200_response result = apiInstance.proxiesTest(proxyId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ProxiesApi#proxiesTest");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: cookieAuth)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"domainflow_session"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"domainflow_session"];


// Create an instance of the API class
ProxiesApi *apiInstance = [[ProxiesApi alloc] init];
UUID *proxyId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; //  (default to null)

// Test proxy
[apiInstance proxiesTestWith:proxyId
              completionHandler: ^(proxies_test_200_response output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var DomainFlowApi = require('domain_flow_api');
var defaultClient = DomainFlowApi.ApiClient.instance;

// Configure API key authorization: cookieAuth
var cookieAuth = defaultClient.authentications['cookieAuth'];
cookieAuth.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//cookieAuth.apiKeyPrefix['domainflow_session'] = "Token";

// Create an instance of the API class
var api = new DomainFlowApi.ProxiesApi()
var proxyId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // {UUID} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.proxiesTest(proxyId, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class proxiesTestExample
    {
        public void main()
        {
            // Configure API key authorization: cookieAuth
            Configuration.Default.ApiKey.Add("domainflow_session", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("domainflow_session", "Bearer");

            // Create an instance of the API class
            var apiInstance = new ProxiesApi();
            var proxyId = 38400000-8cf0-11bd-b23e-10b96e4ef00d;  // UUID |  (default to null)

            try {
                // Test proxy
                proxies_test_200_response result = apiInstance.proxiesTest(proxyId);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling ProxiesApi.proxiesTest: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure API key authorization: cookieAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('domainflow_session', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('domainflow_session', 'Bearer');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\ProxiesApi();
$proxyId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 

try {
    $result = $api_instance->proxiesTest($proxyId);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling ProxiesApi->proxiesTest: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::ProxiesApi;

# Configure API key authorization: cookieAuth
$WWW::OPenAPIClient::Configuration::api_key->{'domainflow_session'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'domainflow_session'} = "Bearer";

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::ProxiesApi->new();
my $proxyId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; # UUID | 

eval {
    my $result = $api_instance->proxiesTest(proxyId => $proxyId);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling ProxiesApi->proxiesTest: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure API key authorization: cookieAuth
openapi_client.configuration.api_key['domainflow_session'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['domainflow_session'] = 'Bearer'

# Create an instance of the API class
api_instance = openapi_client.ProxiesApi()
proxyId = 38400000-8cf0-11bd-b23e-10b96e4ef00d # UUID |  (default to null)

try:
    # Test proxy
    api_response = api_instance.proxies_test(proxyId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ProxiesApi->proxiesTest: %s\n" % e)
extern crate ProxiesApi;

pub fn main() {
    let proxyId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID

    let mut context = ProxiesApi::Context::default();
    let result = client.proxiesTest(proxyId, &context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Path parameters
Name Description
proxyId*
UUID (uuid)
Required

Responses

Name Type Format Description
Retry-After Integer Seconds to wait before retrying


proxiesUpdate

Update proxy


/proxies/{proxyId}

Usage and SDK Samples

curl -X PUT \
 \
 -H "Accept: application/json" \
 -H "Content-Type: application/json" \
 "https://api.domainflow.dev/api/v2/proxies/{proxyId}" \
 -d '{
  "protocol" : "http",
  "password" : "password",
  "address" : "address",
  "notes" : "notes",
  "countryCode" : "countryCode",
  "isEnabled" : true,
  "name" : "name",
  "description" : "description",
  "username" : "username"
}'
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.ProxiesApi;

import java.io.File;
import java.util.*;

public class ProxiesApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure API key authorization: cookieAuth
        ApiKeyAuth cookieAuth = (ApiKeyAuth) defaultClient.getAuthentication("cookieAuth");
        cookieAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //cookieAuth.setApiKeyPrefix("Token");

        // Create an instance of the API class
        ProxiesApi apiInstance = new ProxiesApi();
        UUID proxyId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 
        UpdateProxyRequestAPI updateProxyRequestAPI = ; // UpdateProxyRequestAPI | 

        try {
            proxies_create_201_response result = apiInstance.proxiesUpdate(proxyId, updateProxyRequestAPI);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ProxiesApi#proxiesUpdate");
            e.printStackTrace();
        }
    }
}
import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final UUID proxyId = new UUID(); // UUID | 
final UpdateProxyRequestAPI updateProxyRequestAPI = new UpdateProxyRequestAPI(); // UpdateProxyRequestAPI | 

try {
    final result = await api_instance.proxiesUpdate(proxyId, updateProxyRequestAPI);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->proxiesUpdate: $e\n');
}

import org.openapitools.client.api.ProxiesApi;

public class ProxiesApiExample {
    public static void main(String[] args) {
        ProxiesApi apiInstance = new ProxiesApi();
        UUID proxyId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 
        UpdateProxyRequestAPI updateProxyRequestAPI = ; // UpdateProxyRequestAPI | 

        try {
            proxies_create_201_response result = apiInstance.proxiesUpdate(proxyId, updateProxyRequestAPI);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ProxiesApi#proxiesUpdate");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: cookieAuth)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"domainflow_session"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"domainflow_session"];


// Create an instance of the API class
ProxiesApi *apiInstance = [[ProxiesApi alloc] init];
UUID *proxyId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; //  (default to null)
UpdateProxyRequestAPI *updateProxyRequestAPI = ; // 

// Update proxy
[apiInstance proxiesUpdateWith:proxyId
    updateProxyRequestAPI:updateProxyRequestAPI
              completionHandler: ^(proxies_create_201_response output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var DomainFlowApi = require('domain_flow_api');
var defaultClient = DomainFlowApi.ApiClient.instance;

// Configure API key authorization: cookieAuth
var cookieAuth = defaultClient.authentications['cookieAuth'];
cookieAuth.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//cookieAuth.apiKeyPrefix['domainflow_session'] = "Token";

// Create an instance of the API class
var api = new DomainFlowApi.ProxiesApi()
var proxyId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // {UUID} 
var updateProxyRequestAPI = ; // {UpdateProxyRequestAPI} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.proxiesUpdate(proxyId, updateProxyRequestAPI, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class proxiesUpdateExample
    {
        public void main()
        {
            // Configure API key authorization: cookieAuth
            Configuration.Default.ApiKey.Add("domainflow_session", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("domainflow_session", "Bearer");

            // Create an instance of the API class
            var apiInstance = new ProxiesApi();
            var proxyId = 38400000-8cf0-11bd-b23e-10b96e4ef00d;  // UUID |  (default to null)
            var updateProxyRequestAPI = new UpdateProxyRequestAPI(); // UpdateProxyRequestAPI | 

            try {
                // Update proxy
                proxies_create_201_response result = apiInstance.proxiesUpdate(proxyId, updateProxyRequestAPI);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling ProxiesApi.proxiesUpdate: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure API key authorization: cookieAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('domainflow_session', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('domainflow_session', 'Bearer');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\ProxiesApi();
$proxyId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 
$updateProxyRequestAPI = ; // UpdateProxyRequestAPI | 

try {
    $result = $api_instance->proxiesUpdate($proxyId, $updateProxyRequestAPI);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling ProxiesApi->proxiesUpdate: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::ProxiesApi;

# Configure API key authorization: cookieAuth
$WWW::OPenAPIClient::Configuration::api_key->{'domainflow_session'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'domainflow_session'} = "Bearer";

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::ProxiesApi->new();
my $proxyId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; # UUID | 
my $updateProxyRequestAPI = WWW::OPenAPIClient::Object::UpdateProxyRequestAPI->new(); # UpdateProxyRequestAPI | 

eval {
    my $result = $api_instance->proxiesUpdate(proxyId => $proxyId, updateProxyRequestAPI => $updateProxyRequestAPI);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling ProxiesApi->proxiesUpdate: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure API key authorization: cookieAuth
openapi_client.configuration.api_key['domainflow_session'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['domainflow_session'] = 'Bearer'

# Create an instance of the API class
api_instance = openapi_client.ProxiesApi()
proxyId = 38400000-8cf0-11bd-b23e-10b96e4ef00d # UUID |  (default to null)
updateProxyRequestAPI =  # UpdateProxyRequestAPI | 

try:
    # Update proxy
    api_response = api_instance.proxies_update(proxyId, updateProxyRequestAPI)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ProxiesApi->proxiesUpdate: %s\n" % e)
extern crate ProxiesApi;

pub fn main() {
    let proxyId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID
    let updateProxyRequestAPI = ; // UpdateProxyRequestAPI

    let mut context = ProxiesApi::Context::default();
    let result = client.proxiesUpdate(proxyId, updateProxyRequestAPI, &context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Path parameters
Name Description
proxyId*
UUID (uuid)
Required
Body parameters
Name Description
updateProxyRequestAPI *

Responses


ProxyPools

proxyPoolsAddProxy

Add proxy to pool


/proxy-pools/{poolId}/proxies

Usage and SDK Samples

curl -X POST \
 \
 -H "Accept: application/json" \
 -H "Content-Type: application/json" \
 "https://api.domainflow.dev/api/v2/proxy-pools/{poolId}/proxies" \
 -d ''
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.ProxyPoolsApi;

import java.io.File;
import java.util.*;

public class ProxyPoolsApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure API key authorization: cookieAuth
        ApiKeyAuth cookieAuth = (ApiKeyAuth) defaultClient.getAuthentication("cookieAuth");
        cookieAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //cookieAuth.setApiKeyPrefix("Token");

        // Create an instance of the API class
        ProxyPoolsApi apiInstance = new ProxyPoolsApi();
        UUID poolId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 
        ProxyPoolsAddProxyRequest proxyPoolsAddProxyRequest = ; // ProxyPoolsAddProxyRequest | 

        try {
            proxy_pools_add_proxy_201_response result = apiInstance.proxyPoolsAddProxy(poolId, proxyPoolsAddProxyRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ProxyPoolsApi#proxyPoolsAddProxy");
            e.printStackTrace();
        }
    }
}
import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final UUID poolId = new UUID(); // UUID | 
final ProxyPoolsAddProxyRequest proxyPoolsAddProxyRequest = new ProxyPoolsAddProxyRequest(); // ProxyPoolsAddProxyRequest | 

try {
    final result = await api_instance.proxyPoolsAddProxy(poolId, proxyPoolsAddProxyRequest);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->proxyPoolsAddProxy: $e\n');
}

import org.openapitools.client.api.ProxyPoolsApi;

public class ProxyPoolsApiExample {
    public static void main(String[] args) {
        ProxyPoolsApi apiInstance = new ProxyPoolsApi();
        UUID poolId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 
        ProxyPoolsAddProxyRequest proxyPoolsAddProxyRequest = ; // ProxyPoolsAddProxyRequest | 

        try {
            proxy_pools_add_proxy_201_response result = apiInstance.proxyPoolsAddProxy(poolId, proxyPoolsAddProxyRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ProxyPoolsApi#proxyPoolsAddProxy");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: cookieAuth)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"domainflow_session"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"domainflow_session"];


// Create an instance of the API class
ProxyPoolsApi *apiInstance = [[ProxyPoolsApi alloc] init];
UUID *poolId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; //  (default to null)
ProxyPoolsAddProxyRequest *proxyPoolsAddProxyRequest = ; // 

// Add proxy to pool
[apiInstance proxyPoolsAddProxyWith:poolId
    proxyPoolsAddProxyRequest:proxyPoolsAddProxyRequest
              completionHandler: ^(proxy_pools_add_proxy_201_response output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var DomainFlowApi = require('domain_flow_api');
var defaultClient = DomainFlowApi.ApiClient.instance;

// Configure API key authorization: cookieAuth
var cookieAuth = defaultClient.authentications['cookieAuth'];
cookieAuth.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//cookieAuth.apiKeyPrefix['domainflow_session'] = "Token";

// Create an instance of the API class
var api = new DomainFlowApi.ProxyPoolsApi()
var poolId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // {UUID} 
var proxyPoolsAddProxyRequest = ; // {ProxyPoolsAddProxyRequest} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.proxyPoolsAddProxy(poolId, proxyPoolsAddProxyRequest, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class proxyPoolsAddProxyExample
    {
        public void main()
        {
            // Configure API key authorization: cookieAuth
            Configuration.Default.ApiKey.Add("domainflow_session", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("domainflow_session", "Bearer");

            // Create an instance of the API class
            var apiInstance = new ProxyPoolsApi();
            var poolId = 38400000-8cf0-11bd-b23e-10b96e4ef00d;  // UUID |  (default to null)
            var proxyPoolsAddProxyRequest = new ProxyPoolsAddProxyRequest(); // ProxyPoolsAddProxyRequest | 

            try {
                // Add proxy to pool
                proxy_pools_add_proxy_201_response result = apiInstance.proxyPoolsAddProxy(poolId, proxyPoolsAddProxyRequest);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling ProxyPoolsApi.proxyPoolsAddProxy: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure API key authorization: cookieAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('domainflow_session', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('domainflow_session', 'Bearer');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\ProxyPoolsApi();
$poolId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 
$proxyPoolsAddProxyRequest = ; // ProxyPoolsAddProxyRequest | 

try {
    $result = $api_instance->proxyPoolsAddProxy($poolId, $proxyPoolsAddProxyRequest);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling ProxyPoolsApi->proxyPoolsAddProxy: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::ProxyPoolsApi;

# Configure API key authorization: cookieAuth
$WWW::OPenAPIClient::Configuration::api_key->{'domainflow_session'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'domainflow_session'} = "Bearer";

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::ProxyPoolsApi->new();
my $poolId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; # UUID | 
my $proxyPoolsAddProxyRequest = WWW::OPenAPIClient::Object::ProxyPoolsAddProxyRequest->new(); # ProxyPoolsAddProxyRequest | 

eval {
    my $result = $api_instance->proxyPoolsAddProxy(poolId => $poolId, proxyPoolsAddProxyRequest => $proxyPoolsAddProxyRequest);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling ProxyPoolsApi->proxyPoolsAddProxy: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure API key authorization: cookieAuth
openapi_client.configuration.api_key['domainflow_session'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['domainflow_session'] = 'Bearer'

# Create an instance of the API class
api_instance = openapi_client.ProxyPoolsApi()
poolId = 38400000-8cf0-11bd-b23e-10b96e4ef00d # UUID |  (default to null)
proxyPoolsAddProxyRequest =  # ProxyPoolsAddProxyRequest | 

try:
    # Add proxy to pool
    api_response = api_instance.proxy_pools_add_proxy(poolId, proxyPoolsAddProxyRequest)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ProxyPoolsApi->proxyPoolsAddProxy: %s\n" % e)
extern crate ProxyPoolsApi;

pub fn main() {
    let poolId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID
    let proxyPoolsAddProxyRequest = ; // ProxyPoolsAddProxyRequest

    let mut context = ProxyPoolsApi::Context::default();
    let result = client.proxyPoolsAddProxy(poolId, proxyPoolsAddProxyRequest, &context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Path parameters
Name Description
poolId*
UUID (uuid)
Required
Body parameters
Name Description
proxyPoolsAddProxyRequest *

Responses


proxyPoolsCreate

Create proxy pool


/proxy-pools

Usage and SDK Samples

curl -X POST \
 \
 -H "Accept: application/json" \
 -H "Content-Type: application/json" \
 "https://api.domainflow.dev/api/v2/proxy-pools" \
 -d '{
  "healthCheckEnabled" : true,
  "maxRetries" : 6,
  "isEnabled" : true,
  "healthCheckIntervalSeconds" : 0,
  "name" : "name",
  "description" : "description",
  "timeoutSeconds" : 1,
  "poolStrategy" : "poolStrategy"
}'
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.ProxyPoolsApi;

import java.io.File;
import java.util.*;

public class ProxyPoolsApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure API key authorization: cookieAuth
        ApiKeyAuth cookieAuth = (ApiKeyAuth) defaultClient.getAuthentication("cookieAuth");
        cookieAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //cookieAuth.setApiKeyPrefix("Token");

        // Create an instance of the API class
        ProxyPoolsApi apiInstance = new ProxyPoolsApi();
        ProxyPoolRequest proxyPoolRequest = ; // ProxyPoolRequest | 

        try {
            proxy_pools_create_201_response result = apiInstance.proxyPoolsCreate(proxyPoolRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ProxyPoolsApi#proxyPoolsCreate");
            e.printStackTrace();
        }
    }
}
import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final ProxyPoolRequest proxyPoolRequest = new ProxyPoolRequest(); // ProxyPoolRequest | 

try {
    final result = await api_instance.proxyPoolsCreate(proxyPoolRequest);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->proxyPoolsCreate: $e\n');
}

import org.openapitools.client.api.ProxyPoolsApi;

public class ProxyPoolsApiExample {
    public static void main(String[] args) {
        ProxyPoolsApi apiInstance = new ProxyPoolsApi();
        ProxyPoolRequest proxyPoolRequest = ; // ProxyPoolRequest | 

        try {
            proxy_pools_create_201_response result = apiInstance.proxyPoolsCreate(proxyPoolRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ProxyPoolsApi#proxyPoolsCreate");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: cookieAuth)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"domainflow_session"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"domainflow_session"];


// Create an instance of the API class
ProxyPoolsApi *apiInstance = [[ProxyPoolsApi alloc] init];
ProxyPoolRequest *proxyPoolRequest = ; // 

// Create proxy pool
[apiInstance proxyPoolsCreateWith:proxyPoolRequest
              completionHandler: ^(proxy_pools_create_201_response output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var DomainFlowApi = require('domain_flow_api');
var defaultClient = DomainFlowApi.ApiClient.instance;

// Configure API key authorization: cookieAuth
var cookieAuth = defaultClient.authentications['cookieAuth'];
cookieAuth.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//cookieAuth.apiKeyPrefix['domainflow_session'] = "Token";

// Create an instance of the API class
var api = new DomainFlowApi.ProxyPoolsApi()
var proxyPoolRequest = ; // {ProxyPoolRequest} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.proxyPoolsCreate(proxyPoolRequest, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class proxyPoolsCreateExample
    {
        public void main()
        {
            // Configure API key authorization: cookieAuth
            Configuration.Default.ApiKey.Add("domainflow_session", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("domainflow_session", "Bearer");

            // Create an instance of the API class
            var apiInstance = new ProxyPoolsApi();
            var proxyPoolRequest = new ProxyPoolRequest(); // ProxyPoolRequest | 

            try {
                // Create proxy pool
                proxy_pools_create_201_response result = apiInstance.proxyPoolsCreate(proxyPoolRequest);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling ProxyPoolsApi.proxyPoolsCreate: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure API key authorization: cookieAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('domainflow_session', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('domainflow_session', 'Bearer');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\ProxyPoolsApi();
$proxyPoolRequest = ; // ProxyPoolRequest | 

try {
    $result = $api_instance->proxyPoolsCreate($proxyPoolRequest);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling ProxyPoolsApi->proxyPoolsCreate: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::ProxyPoolsApi;

# Configure API key authorization: cookieAuth
$WWW::OPenAPIClient::Configuration::api_key->{'domainflow_session'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'domainflow_session'} = "Bearer";

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::ProxyPoolsApi->new();
my $proxyPoolRequest = WWW::OPenAPIClient::Object::ProxyPoolRequest->new(); # ProxyPoolRequest | 

eval {
    my $result = $api_instance->proxyPoolsCreate(proxyPoolRequest => $proxyPoolRequest);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling ProxyPoolsApi->proxyPoolsCreate: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure API key authorization: cookieAuth
openapi_client.configuration.api_key['domainflow_session'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['domainflow_session'] = 'Bearer'

# Create an instance of the API class
api_instance = openapi_client.ProxyPoolsApi()
proxyPoolRequest =  # ProxyPoolRequest | 

try:
    # Create proxy pool
    api_response = api_instance.proxy_pools_create(proxyPoolRequest)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ProxyPoolsApi->proxyPoolsCreate: %s\n" % e)
extern crate ProxyPoolsApi;

pub fn main() {
    let proxyPoolRequest = ; // ProxyPoolRequest

    let mut context = ProxyPoolsApi::Context::default();
    let result = client.proxyPoolsCreate(proxyPoolRequest, &context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Body parameters
Name Description
proxyPoolRequest *

Responses


proxyPoolsDelete

Delete proxy pool


/proxy-pools/{poolId}

Usage and SDK Samples

curl -X DELETE \
 \
 -H "Accept: application/json" \
 "https://api.domainflow.dev/api/v2/proxy-pools/{poolId}"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.ProxyPoolsApi;

import java.io.File;
import java.util.*;

public class ProxyPoolsApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure API key authorization: cookieAuth
        ApiKeyAuth cookieAuth = (ApiKeyAuth) defaultClient.getAuthentication("cookieAuth");
        cookieAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //cookieAuth.setApiKeyPrefix("Token");

        // Create an instance of the API class
        ProxyPoolsApi apiInstance = new ProxyPoolsApi();
        UUID poolId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 

        try {
            proxy_pools_delete_200_response result = apiInstance.proxyPoolsDelete(poolId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ProxyPoolsApi#proxyPoolsDelete");
            e.printStackTrace();
        }
    }
}
import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final UUID poolId = new UUID(); // UUID | 

try {
    final result = await api_instance.proxyPoolsDelete(poolId);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->proxyPoolsDelete: $e\n');
}

import org.openapitools.client.api.ProxyPoolsApi;

public class ProxyPoolsApiExample {
    public static void main(String[] args) {
        ProxyPoolsApi apiInstance = new ProxyPoolsApi();
        UUID poolId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 

        try {
            proxy_pools_delete_200_response result = apiInstance.proxyPoolsDelete(poolId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ProxyPoolsApi#proxyPoolsDelete");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: cookieAuth)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"domainflow_session"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"domainflow_session"];


// Create an instance of the API class
ProxyPoolsApi *apiInstance = [[ProxyPoolsApi alloc] init];
UUID *poolId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; //  (default to null)

// Delete proxy pool
[apiInstance proxyPoolsDeleteWith:poolId
              completionHandler: ^(proxy_pools_delete_200_response output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var DomainFlowApi = require('domain_flow_api');
var defaultClient = DomainFlowApi.ApiClient.instance;

// Configure API key authorization: cookieAuth
var cookieAuth = defaultClient.authentications['cookieAuth'];
cookieAuth.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//cookieAuth.apiKeyPrefix['domainflow_session'] = "Token";

// Create an instance of the API class
var api = new DomainFlowApi.ProxyPoolsApi()
var poolId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // {UUID} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.proxyPoolsDelete(poolId, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class proxyPoolsDeleteExample
    {
        public void main()
        {
            // Configure API key authorization: cookieAuth
            Configuration.Default.ApiKey.Add("domainflow_session", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("domainflow_session", "Bearer");

            // Create an instance of the API class
            var apiInstance = new ProxyPoolsApi();
            var poolId = 38400000-8cf0-11bd-b23e-10b96e4ef00d;  // UUID |  (default to null)

            try {
                // Delete proxy pool
                proxy_pools_delete_200_response result = apiInstance.proxyPoolsDelete(poolId);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling ProxyPoolsApi.proxyPoolsDelete: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure API key authorization: cookieAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('domainflow_session', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('domainflow_session', 'Bearer');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\ProxyPoolsApi();
$poolId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 

try {
    $result = $api_instance->proxyPoolsDelete($poolId);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling ProxyPoolsApi->proxyPoolsDelete: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::ProxyPoolsApi;

# Configure API key authorization: cookieAuth
$WWW::OPenAPIClient::Configuration::api_key->{'domainflow_session'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'domainflow_session'} = "Bearer";

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::ProxyPoolsApi->new();
my $poolId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; # UUID | 

eval {
    my $result = $api_instance->proxyPoolsDelete(poolId => $poolId);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling ProxyPoolsApi->proxyPoolsDelete: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure API key authorization: cookieAuth
openapi_client.configuration.api_key['domainflow_session'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['domainflow_session'] = 'Bearer'

# Create an instance of the API class
api_instance = openapi_client.ProxyPoolsApi()
poolId = 38400000-8cf0-11bd-b23e-10b96e4ef00d # UUID |  (default to null)

try:
    # Delete proxy pool
    api_response = api_instance.proxy_pools_delete(poolId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ProxyPoolsApi->proxyPoolsDelete: %s\n" % e)
extern crate ProxyPoolsApi;

pub fn main() {
    let poolId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID

    let mut context = ProxyPoolsApi::Context::default();
    let result = client.proxyPoolsDelete(poolId, &context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Path parameters
Name Description
poolId*
UUID (uuid)
Required

Responses


proxyPoolsList

List proxy pools


/proxy-pools

Usage and SDK Samples

curl -X GET \
 \
 -H "Accept: application/json" \
 "https://api.domainflow.dev/api/v2/proxy-pools"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.ProxyPoolsApi;

import java.io.File;
import java.util.*;

public class ProxyPoolsApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure API key authorization: cookieAuth
        ApiKeyAuth cookieAuth = (ApiKeyAuth) defaultClient.getAuthentication("cookieAuth");
        cookieAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //cookieAuth.setApiKeyPrefix("Token");

        // Create an instance of the API class
        ProxyPoolsApi apiInstance = new ProxyPoolsApi();

        try {
            proxy_pools_list_200_response result = apiInstance.proxyPoolsList();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ProxyPoolsApi#proxyPoolsList");
            e.printStackTrace();
        }
    }
}
import 'package:openapi/api.dart';

final api_instance = DefaultApi();


try {
    final result = await api_instance.proxyPoolsList();
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->proxyPoolsList: $e\n');
}

import org.openapitools.client.api.ProxyPoolsApi;

public class ProxyPoolsApiExample {
    public static void main(String[] args) {
        ProxyPoolsApi apiInstance = new ProxyPoolsApi();

        try {
            proxy_pools_list_200_response result = apiInstance.proxyPoolsList();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ProxyPoolsApi#proxyPoolsList");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: cookieAuth)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"domainflow_session"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"domainflow_session"];


// Create an instance of the API class
ProxyPoolsApi *apiInstance = [[ProxyPoolsApi alloc] init];

// List proxy pools
[apiInstance proxyPoolsListWithCompletionHandler: 
              ^(proxy_pools_list_200_response output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var DomainFlowApi = require('domain_flow_api');
var defaultClient = DomainFlowApi.ApiClient.instance;

// Configure API key authorization: cookieAuth
var cookieAuth = defaultClient.authentications['cookieAuth'];
cookieAuth.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//cookieAuth.apiKeyPrefix['domainflow_session'] = "Token";

// Create an instance of the API class
var api = new DomainFlowApi.ProxyPoolsApi()
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.proxyPoolsList(callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class proxyPoolsListExample
    {
        public void main()
        {
            // Configure API key authorization: cookieAuth
            Configuration.Default.ApiKey.Add("domainflow_session", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("domainflow_session", "Bearer");

            // Create an instance of the API class
            var apiInstance = new ProxyPoolsApi();

            try {
                // List proxy pools
                proxy_pools_list_200_response result = apiInstance.proxyPoolsList();
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling ProxyPoolsApi.proxyPoolsList: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure API key authorization: cookieAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('domainflow_session', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('domainflow_session', 'Bearer');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\ProxyPoolsApi();

try {
    $result = $api_instance->proxyPoolsList();
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling ProxyPoolsApi->proxyPoolsList: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::ProxyPoolsApi;

# Configure API key authorization: cookieAuth
$WWW::OPenAPIClient::Configuration::api_key->{'domainflow_session'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'domainflow_session'} = "Bearer";

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::ProxyPoolsApi->new();

eval {
    my $result = $api_instance->proxyPoolsList();
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling ProxyPoolsApi->proxyPoolsList: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure API key authorization: cookieAuth
openapi_client.configuration.api_key['domainflow_session'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['domainflow_session'] = 'Bearer'

# Create an instance of the API class
api_instance = openapi_client.ProxyPoolsApi()

try:
    # List proxy pools
    api_response = api_instance.proxy_pools_list()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ProxyPoolsApi->proxyPoolsList: %s\n" % e)
extern crate ProxyPoolsApi;

pub fn main() {

    let mut context = ProxyPoolsApi::Context::default();
    let result = client.proxyPoolsList(&context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Responses


proxyPoolsRemoveProxy

Remove proxy from pool


/proxy-pools/{poolId}/proxies/{proxyId}

Usage and SDK Samples

curl -X DELETE \
 \
 -H "Accept: application/json" \
 "https://api.domainflow.dev/api/v2/proxy-pools/{poolId}/proxies/{proxyId}"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.ProxyPoolsApi;

import java.io.File;
import java.util.*;

public class ProxyPoolsApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure API key authorization: cookieAuth
        ApiKeyAuth cookieAuth = (ApiKeyAuth) defaultClient.getAuthentication("cookieAuth");
        cookieAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //cookieAuth.setApiKeyPrefix("Token");

        // Create an instance of the API class
        ProxyPoolsApi apiInstance = new ProxyPoolsApi();
        UUID poolId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 
        UUID proxyId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 

        try {
            proxy_pools_remove_proxy_200_response result = apiInstance.proxyPoolsRemoveProxy(poolId, proxyId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ProxyPoolsApi#proxyPoolsRemoveProxy");
            e.printStackTrace();
        }
    }
}
import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final UUID poolId = new UUID(); // UUID | 
final UUID proxyId = new UUID(); // UUID | 

try {
    final result = await api_instance.proxyPoolsRemoveProxy(poolId, proxyId);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->proxyPoolsRemoveProxy: $e\n');
}

import org.openapitools.client.api.ProxyPoolsApi;

public class ProxyPoolsApiExample {
    public static void main(String[] args) {
        ProxyPoolsApi apiInstance = new ProxyPoolsApi();
        UUID poolId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 
        UUID proxyId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 

        try {
            proxy_pools_remove_proxy_200_response result = apiInstance.proxyPoolsRemoveProxy(poolId, proxyId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ProxyPoolsApi#proxyPoolsRemoveProxy");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: cookieAuth)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"domainflow_session"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"domainflow_session"];


// Create an instance of the API class
ProxyPoolsApi *apiInstance = [[ProxyPoolsApi alloc] init];
UUID *poolId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; //  (default to null)
UUID *proxyId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; //  (default to null)

// Remove proxy from pool
[apiInstance proxyPoolsRemoveProxyWith:poolId
    proxyId:proxyId
              completionHandler: ^(proxy_pools_remove_proxy_200_response output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var DomainFlowApi = require('domain_flow_api');
var defaultClient = DomainFlowApi.ApiClient.instance;

// Configure API key authorization: cookieAuth
var cookieAuth = defaultClient.authentications['cookieAuth'];
cookieAuth.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//cookieAuth.apiKeyPrefix['domainflow_session'] = "Token";

// Create an instance of the API class
var api = new DomainFlowApi.ProxyPoolsApi()
var poolId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // {UUID} 
var proxyId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // {UUID} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.proxyPoolsRemoveProxy(poolId, proxyId, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class proxyPoolsRemoveProxyExample
    {
        public void main()
        {
            // Configure API key authorization: cookieAuth
            Configuration.Default.ApiKey.Add("domainflow_session", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("domainflow_session", "Bearer");

            // Create an instance of the API class
            var apiInstance = new ProxyPoolsApi();
            var poolId = 38400000-8cf0-11bd-b23e-10b96e4ef00d;  // UUID |  (default to null)
            var proxyId = 38400000-8cf0-11bd-b23e-10b96e4ef00d;  // UUID |  (default to null)

            try {
                // Remove proxy from pool
                proxy_pools_remove_proxy_200_response result = apiInstance.proxyPoolsRemoveProxy(poolId, proxyId);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling ProxyPoolsApi.proxyPoolsRemoveProxy: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure API key authorization: cookieAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('domainflow_session', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('domainflow_session', 'Bearer');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\ProxyPoolsApi();
$poolId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 
$proxyId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 

try {
    $result = $api_instance->proxyPoolsRemoveProxy($poolId, $proxyId);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling ProxyPoolsApi->proxyPoolsRemoveProxy: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::ProxyPoolsApi;

# Configure API key authorization: cookieAuth
$WWW::OPenAPIClient::Configuration::api_key->{'domainflow_session'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'domainflow_session'} = "Bearer";

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::ProxyPoolsApi->new();
my $poolId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; # UUID | 
my $proxyId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; # UUID | 

eval {
    my $result = $api_instance->proxyPoolsRemoveProxy(poolId => $poolId, proxyId => $proxyId);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling ProxyPoolsApi->proxyPoolsRemoveProxy: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure API key authorization: cookieAuth
openapi_client.configuration.api_key['domainflow_session'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['domainflow_session'] = 'Bearer'

# Create an instance of the API class
api_instance = openapi_client.ProxyPoolsApi()
poolId = 38400000-8cf0-11bd-b23e-10b96e4ef00d # UUID |  (default to null)
proxyId = 38400000-8cf0-11bd-b23e-10b96e4ef00d # UUID |  (default to null)

try:
    # Remove proxy from pool
    api_response = api_instance.proxy_pools_remove_proxy(poolId, proxyId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ProxyPoolsApi->proxyPoolsRemoveProxy: %s\n" % e)
extern crate ProxyPoolsApi;

pub fn main() {
    let poolId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID
    let proxyId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID

    let mut context = ProxyPoolsApi::Context::default();
    let result = client.proxyPoolsRemoveProxy(poolId, proxyId, &context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Path parameters
Name Description
poolId*
UUID (uuid)
Required
proxyId*
UUID (uuid)
Required

Responses


proxyPoolsUpdate

Update proxy pool


/proxy-pools/{poolId}

Usage and SDK Samples

curl -X PUT \
 \
 -H "Accept: application/json" \
 -H "Content-Type: application/json" \
 "https://api.domainflow.dev/api/v2/proxy-pools/{poolId}" \
 -d '{
  "healthCheckEnabled" : true,
  "maxRetries" : 6,
  "isEnabled" : true,
  "healthCheckIntervalSeconds" : 0,
  "name" : "name",
  "description" : "description",
  "timeoutSeconds" : 1,
  "poolStrategy" : "poolStrategy"
}'
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.ProxyPoolsApi;

import java.io.File;
import java.util.*;

public class ProxyPoolsApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure API key authorization: cookieAuth
        ApiKeyAuth cookieAuth = (ApiKeyAuth) defaultClient.getAuthentication("cookieAuth");
        cookieAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //cookieAuth.setApiKeyPrefix("Token");

        // Create an instance of the API class
        ProxyPoolsApi apiInstance = new ProxyPoolsApi();
        UUID poolId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 
        ProxyPoolRequest proxyPoolRequest = ; // ProxyPoolRequest | 

        try {
            proxy_pools_create_201_response result = apiInstance.proxyPoolsUpdate(poolId, proxyPoolRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ProxyPoolsApi#proxyPoolsUpdate");
            e.printStackTrace();
        }
    }
}
import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final UUID poolId = new UUID(); // UUID | 
final ProxyPoolRequest proxyPoolRequest = new ProxyPoolRequest(); // ProxyPoolRequest | 

try {
    final result = await api_instance.proxyPoolsUpdate(poolId, proxyPoolRequest);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->proxyPoolsUpdate: $e\n');
}

import org.openapitools.client.api.ProxyPoolsApi;

public class ProxyPoolsApiExample {
    public static void main(String[] args) {
        ProxyPoolsApi apiInstance = new ProxyPoolsApi();
        UUID poolId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 
        ProxyPoolRequest proxyPoolRequest = ; // ProxyPoolRequest | 

        try {
            proxy_pools_create_201_response result = apiInstance.proxyPoolsUpdate(poolId, proxyPoolRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ProxyPoolsApi#proxyPoolsUpdate");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: cookieAuth)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"domainflow_session"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"domainflow_session"];


// Create an instance of the API class
ProxyPoolsApi *apiInstance = [[ProxyPoolsApi alloc] init];
UUID *poolId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; //  (default to null)
ProxyPoolRequest *proxyPoolRequest = ; // 

// Update proxy pool
[apiInstance proxyPoolsUpdateWith:poolId
    proxyPoolRequest:proxyPoolRequest
              completionHandler: ^(proxy_pools_create_201_response output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var DomainFlowApi = require('domain_flow_api');
var defaultClient = DomainFlowApi.ApiClient.instance;

// Configure API key authorization: cookieAuth
var cookieAuth = defaultClient.authentications['cookieAuth'];
cookieAuth.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//cookieAuth.apiKeyPrefix['domainflow_session'] = "Token";

// Create an instance of the API class
var api = new DomainFlowApi.ProxyPoolsApi()
var poolId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // {UUID} 
var proxyPoolRequest = ; // {ProxyPoolRequest} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.proxyPoolsUpdate(poolId, proxyPoolRequest, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class proxyPoolsUpdateExample
    {
        public void main()
        {
            // Configure API key authorization: cookieAuth
            Configuration.Default.ApiKey.Add("domainflow_session", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("domainflow_session", "Bearer");

            // Create an instance of the API class
            var apiInstance = new ProxyPoolsApi();
            var poolId = 38400000-8cf0-11bd-b23e-10b96e4ef00d;  // UUID |  (default to null)
            var proxyPoolRequest = new ProxyPoolRequest(); // ProxyPoolRequest | 

            try {
                // Update proxy pool
                proxy_pools_create_201_response result = apiInstance.proxyPoolsUpdate(poolId, proxyPoolRequest);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling ProxyPoolsApi.proxyPoolsUpdate: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure API key authorization: cookieAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('domainflow_session', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('domainflow_session', 'Bearer');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\ProxyPoolsApi();
$poolId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 
$proxyPoolRequest = ; // ProxyPoolRequest | 

try {
    $result = $api_instance->proxyPoolsUpdate($poolId, $proxyPoolRequest);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling ProxyPoolsApi->proxyPoolsUpdate: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::ProxyPoolsApi;

# Configure API key authorization: cookieAuth
$WWW::OPenAPIClient::Configuration::api_key->{'domainflow_session'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'domainflow_session'} = "Bearer";

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::ProxyPoolsApi->new();
my $poolId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; # UUID | 
my $proxyPoolRequest = WWW::OPenAPIClient::Object::ProxyPoolRequest->new(); # ProxyPoolRequest | 

eval {
    my $result = $api_instance->proxyPoolsUpdate(poolId => $poolId, proxyPoolRequest => $proxyPoolRequest);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling ProxyPoolsApi->proxyPoolsUpdate: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure API key authorization: cookieAuth
openapi_client.configuration.api_key['domainflow_session'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['domainflow_session'] = 'Bearer'

# Create an instance of the API class
api_instance = openapi_client.ProxyPoolsApi()
poolId = 38400000-8cf0-11bd-b23e-10b96e4ef00d # UUID |  (default to null)
proxyPoolRequest =  # ProxyPoolRequest | 

try:
    # Update proxy pool
    api_response = api_instance.proxy_pools_update(poolId, proxyPoolRequest)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ProxyPoolsApi->proxyPoolsUpdate: %s\n" % e)
extern crate ProxyPoolsApi;

pub fn main() {
    let poolId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID
    let proxyPoolRequest = ; // ProxyPoolRequest

    let mut context = ProxyPoolsApi::Context::default();
    let result = client.proxyPoolsUpdate(poolId, proxyPoolRequest, &context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Path parameters
Name Description
poolId*
UUID (uuid)
Required
Body parameters
Name Description
proxyPoolRequest *

Responses


ServerSettings

configGetAuth

Get authentication configuration


/config/auth

Usage and SDK Samples

curl -X GET \
 \
 -H "Accept: application/json" \
 "https://api.domainflow.dev/api/v2/config/auth"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.ServerSettingsApi;

import java.io.File;
import java.util.*;

public class ServerSettingsApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure API key authorization: cookieAuth
        ApiKeyAuth cookieAuth = (ApiKeyAuth) defaultClient.getAuthentication("cookieAuth");
        cookieAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //cookieAuth.setApiKeyPrefix("Token");

        // Create an instance of the API class
        ServerSettingsApi apiInstance = new ServerSettingsApi();

        try {
            config_get_auth_200_response result = apiInstance.configGetAuth();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ServerSettingsApi#configGetAuth");
            e.printStackTrace();
        }
    }
}
import 'package:openapi/api.dart';

final api_instance = DefaultApi();


try {
    final result = await api_instance.configGetAuth();
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->configGetAuth: $e\n');
}

import org.openapitools.client.api.ServerSettingsApi;

public class ServerSettingsApiExample {
    public static void main(String[] args) {
        ServerSettingsApi apiInstance = new ServerSettingsApi();

        try {
            config_get_auth_200_response result = apiInstance.configGetAuth();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ServerSettingsApi#configGetAuth");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: cookieAuth)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"domainflow_session"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"domainflow_session"];


// Create an instance of the API class
ServerSettingsApi *apiInstance = [[ServerSettingsApi alloc] init];

// Get authentication configuration
[apiInstance configGetAuthWithCompletionHandler: 
              ^(config_get_auth_200_response output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var DomainFlowApi = require('domain_flow_api');
var defaultClient = DomainFlowApi.ApiClient.instance;

// Configure API key authorization: cookieAuth
var cookieAuth = defaultClient.authentications['cookieAuth'];
cookieAuth.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//cookieAuth.apiKeyPrefix['domainflow_session'] = "Token";

// Create an instance of the API class
var api = new DomainFlowApi.ServerSettingsApi()
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.configGetAuth(callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class configGetAuthExample
    {
        public void main()
        {
            // Configure API key authorization: cookieAuth
            Configuration.Default.ApiKey.Add("domainflow_session", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("domainflow_session", "Bearer");

            // Create an instance of the API class
            var apiInstance = new ServerSettingsApi();

            try {
                // Get authentication configuration
                config_get_auth_200_response result = apiInstance.configGetAuth();
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling ServerSettingsApi.configGetAuth: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure API key authorization: cookieAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('domainflow_session', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('domainflow_session', 'Bearer');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\ServerSettingsApi();

try {
    $result = $api_instance->configGetAuth();
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling ServerSettingsApi->configGetAuth: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::ServerSettingsApi;

# Configure API key authorization: cookieAuth
$WWW::OPenAPIClient::Configuration::api_key->{'domainflow_session'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'domainflow_session'} = "Bearer";

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::ServerSettingsApi->new();

eval {
    my $result = $api_instance->configGetAuth();
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling ServerSettingsApi->configGetAuth: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure API key authorization: cookieAuth
openapi_client.configuration.api_key['domainflow_session'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['domainflow_session'] = 'Bearer'

# Create an instance of the API class
api_instance = openapi_client.ServerSettingsApi()

try:
    # Get authentication configuration
    api_response = api_instance.config_get_auth()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ServerSettingsApi->configGetAuth: %s\n" % e)
extern crate ServerSettingsApi;

pub fn main() {

    let mut context = ServerSettingsApi::Context::default();
    let result = client.configGetAuth(&context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Responses

Name Type Format Description
Retry-After Integer Seconds to wait before retrying


configGetDns

Get DNS configuration


/config/dns

Usage and SDK Samples

curl -X GET \
 \
 -H "Accept: application/json" \
 "https://api.domainflow.dev/api/v2/config/dns"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.ServerSettingsApi;

import java.io.File;
import java.util.*;

public class ServerSettingsApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure API key authorization: cookieAuth
        ApiKeyAuth cookieAuth = (ApiKeyAuth) defaultClient.getAuthentication("cookieAuth");
        cookieAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //cookieAuth.setApiKeyPrefix("Token");

        // Create an instance of the API class
        ServerSettingsApi apiInstance = new ServerSettingsApi();

        try {
            config_get_dns_200_response result = apiInstance.configGetDns();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ServerSettingsApi#configGetDns");
            e.printStackTrace();
        }
    }
}
import 'package:openapi/api.dart';

final api_instance = DefaultApi();


try {
    final result = await api_instance.configGetDns();
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->configGetDns: $e\n');
}

import org.openapitools.client.api.ServerSettingsApi;

public class ServerSettingsApiExample {
    public static void main(String[] args) {
        ServerSettingsApi apiInstance = new ServerSettingsApi();

        try {
            config_get_dns_200_response result = apiInstance.configGetDns();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ServerSettingsApi#configGetDns");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: cookieAuth)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"domainflow_session"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"domainflow_session"];


// Create an instance of the API class
ServerSettingsApi *apiInstance = [[ServerSettingsApi alloc] init];

// Get DNS configuration
[apiInstance configGetDnsWithCompletionHandler: 
              ^(config_get_dns_200_response output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var DomainFlowApi = require('domain_flow_api');
var defaultClient = DomainFlowApi.ApiClient.instance;

// Configure API key authorization: cookieAuth
var cookieAuth = defaultClient.authentications['cookieAuth'];
cookieAuth.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//cookieAuth.apiKeyPrefix['domainflow_session'] = "Token";

// Create an instance of the API class
var api = new DomainFlowApi.ServerSettingsApi()
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.configGetDns(callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class configGetDnsExample
    {
        public void main()
        {
            // Configure API key authorization: cookieAuth
            Configuration.Default.ApiKey.Add("domainflow_session", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("domainflow_session", "Bearer");

            // Create an instance of the API class
            var apiInstance = new ServerSettingsApi();

            try {
                // Get DNS configuration
                config_get_dns_200_response result = apiInstance.configGetDns();
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling ServerSettingsApi.configGetDns: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure API key authorization: cookieAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('domainflow_session', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('domainflow_session', 'Bearer');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\ServerSettingsApi();

try {
    $result = $api_instance->configGetDns();
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling ServerSettingsApi->configGetDns: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::ServerSettingsApi;

# Configure API key authorization: cookieAuth
$WWW::OPenAPIClient::Configuration::api_key->{'domainflow_session'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'domainflow_session'} = "Bearer";

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::ServerSettingsApi->new();

eval {
    my $result = $api_instance->configGetDns();
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling ServerSettingsApi->configGetDns: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure API key authorization: cookieAuth
openapi_client.configuration.api_key['domainflow_session'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['domainflow_session'] = 'Bearer'

# Create an instance of the API class
api_instance = openapi_client.ServerSettingsApi()

try:
    # Get DNS configuration
    api_response = api_instance.config_get_dns()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ServerSettingsApi->configGetDns: %s\n" % e)
extern crate ServerSettingsApi;

pub fn main() {

    let mut context = ServerSettingsApi::Context::default();
    let result = client.configGetDns(&context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Responses

Name Type Format Description
Retry-After Integer Seconds to wait before retrying


configGetHttp

Get HTTP configuration


/config/http

Usage and SDK Samples

curl -X GET \
 \
 -H "Accept: application/json" \
 "https://api.domainflow.dev/api/v2/config/http"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.ServerSettingsApi;

import java.io.File;
import java.util.*;

public class ServerSettingsApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure API key authorization: cookieAuth
        ApiKeyAuth cookieAuth = (ApiKeyAuth) defaultClient.getAuthentication("cookieAuth");
        cookieAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //cookieAuth.setApiKeyPrefix("Token");

        // Create an instance of the API class
        ServerSettingsApi apiInstance = new ServerSettingsApi();

        try {
            Object result = apiInstance.configGetHttp();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ServerSettingsApi#configGetHttp");
            e.printStackTrace();
        }
    }
}
import 'package:openapi/api.dart';

final api_instance = DefaultApi();


try {
    final result = await api_instance.configGetHttp();
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->configGetHttp: $e\n');
}

import org.openapitools.client.api.ServerSettingsApi;

public class ServerSettingsApiExample {
    public static void main(String[] args) {
        ServerSettingsApi apiInstance = new ServerSettingsApi();

        try {
            Object result = apiInstance.configGetHttp();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ServerSettingsApi#configGetHttp");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: cookieAuth)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"domainflow_session"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"domainflow_session"];


// Create an instance of the API class
ServerSettingsApi *apiInstance = [[ServerSettingsApi alloc] init];

// Get HTTP configuration
[apiInstance configGetHttpWithCompletionHandler: 
              ^(Object output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var DomainFlowApi = require('domain_flow_api');
var defaultClient = DomainFlowApi.ApiClient.instance;

// Configure API key authorization: cookieAuth
var cookieAuth = defaultClient.authentications['cookieAuth'];
cookieAuth.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//cookieAuth.apiKeyPrefix['domainflow_session'] = "Token";

// Create an instance of the API class
var api = new DomainFlowApi.ServerSettingsApi()
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.configGetHttp(callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class configGetHttpExample
    {
        public void main()
        {
            // Configure API key authorization: cookieAuth
            Configuration.Default.ApiKey.Add("domainflow_session", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("domainflow_session", "Bearer");

            // Create an instance of the API class
            var apiInstance = new ServerSettingsApi();

            try {
                // Get HTTP configuration
                Object result = apiInstance.configGetHttp();
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling ServerSettingsApi.configGetHttp: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure API key authorization: cookieAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('domainflow_session', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('domainflow_session', 'Bearer');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\ServerSettingsApi();

try {
    $result = $api_instance->configGetHttp();
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling ServerSettingsApi->configGetHttp: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::ServerSettingsApi;

# Configure API key authorization: cookieAuth
$WWW::OPenAPIClient::Configuration::api_key->{'domainflow_session'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'domainflow_session'} = "Bearer";

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::ServerSettingsApi->new();

eval {
    my $result = $api_instance->configGetHttp();
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling ServerSettingsApi->configGetHttp: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure API key authorization: cookieAuth
openapi_client.configuration.api_key['domainflow_session'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['domainflow_session'] = 'Bearer'

# Create an instance of the API class
api_instance = openapi_client.ServerSettingsApi()

try:
    # Get HTTP configuration
    api_response = api_instance.config_get_http()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ServerSettingsApi->configGetHttp: %s\n" % e)
extern crate ServerSettingsApi;

pub fn main() {

    let mut context = ServerSettingsApi::Context::default();
    let result = client.configGetHttp(&context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Responses

Name Type Format Description
Retry-After Integer Seconds to wait before retrying


configGetLogging

Get logging configuration


/config/logging

Usage and SDK Samples

curl -X GET \
 \
 -H "Accept: application/json" \
 "https://api.domainflow.dev/api/v2/config/logging"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.ServerSettingsApi;

import java.io.File;
import java.util.*;

public class ServerSettingsApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure API key authorization: cookieAuth
        ApiKeyAuth cookieAuth = (ApiKeyAuth) defaultClient.getAuthentication("cookieAuth");
        cookieAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //cookieAuth.setApiKeyPrefix("Token");

        // Create an instance of the API class
        ServerSettingsApi apiInstance = new ServerSettingsApi();

        try {
            config_get_logging_200_response result = apiInstance.configGetLogging();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ServerSettingsApi#configGetLogging");
            e.printStackTrace();
        }
    }
}
import 'package:openapi/api.dart';

final api_instance = DefaultApi();


try {
    final result = await api_instance.configGetLogging();
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->configGetLogging: $e\n');
}

import org.openapitools.client.api.ServerSettingsApi;

public class ServerSettingsApiExample {
    public static void main(String[] args) {
        ServerSettingsApi apiInstance = new ServerSettingsApi();

        try {
            config_get_logging_200_response result = apiInstance.configGetLogging();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ServerSettingsApi#configGetLogging");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: cookieAuth)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"domainflow_session"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"domainflow_session"];


// Create an instance of the API class
ServerSettingsApi *apiInstance = [[ServerSettingsApi alloc] init];

// Get logging configuration
[apiInstance configGetLoggingWithCompletionHandler: 
              ^(config_get_logging_200_response output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var DomainFlowApi = require('domain_flow_api');
var defaultClient = DomainFlowApi.ApiClient.instance;

// Configure API key authorization: cookieAuth
var cookieAuth = defaultClient.authentications['cookieAuth'];
cookieAuth.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//cookieAuth.apiKeyPrefix['domainflow_session'] = "Token";

// Create an instance of the API class
var api = new DomainFlowApi.ServerSettingsApi()
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.configGetLogging(callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class configGetLoggingExample
    {
        public void main()
        {
            // Configure API key authorization: cookieAuth
            Configuration.Default.ApiKey.Add("domainflow_session", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("domainflow_session", "Bearer");

            // Create an instance of the API class
            var apiInstance = new ServerSettingsApi();

            try {
                // Get logging configuration
                config_get_logging_200_response result = apiInstance.configGetLogging();
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling ServerSettingsApi.configGetLogging: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure API key authorization: cookieAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('domainflow_session', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('domainflow_session', 'Bearer');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\ServerSettingsApi();

try {
    $result = $api_instance->configGetLogging();
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling ServerSettingsApi->configGetLogging: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::ServerSettingsApi;

# Configure API key authorization: cookieAuth
$WWW::OPenAPIClient::Configuration::api_key->{'domainflow_session'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'domainflow_session'} = "Bearer";

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::ServerSettingsApi->new();

eval {
    my $result = $api_instance->configGetLogging();
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling ServerSettingsApi->configGetLogging: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure API key authorization: cookieAuth
openapi_client.configuration.api_key['domainflow_session'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['domainflow_session'] = 'Bearer'

# Create an instance of the API class
api_instance = openapi_client.ServerSettingsApi()

try:
    # Get logging configuration
    api_response = api_instance.config_get_logging()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ServerSettingsApi->configGetLogging: %s\n" % e)
extern crate ServerSettingsApi;

pub fn main() {

    let mut context = ServerSettingsApi::Context::default();
    let result = client.configGetLogging(&context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Responses

Name Type Format Description
Retry-After Integer Seconds to wait before retrying


configGetProxyManager

Get proxy manager configuration


/config/proxy-manager

Usage and SDK Samples

curl -X GET \
 \
 -H "Accept: application/json" \
 "https://api.domainflow.dev/api/v2/config/proxy-manager"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.ServerSettingsApi;

import java.io.File;
import java.util.*;

public class ServerSettingsApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure API key authorization: cookieAuth
        ApiKeyAuth cookieAuth = (ApiKeyAuth) defaultClient.getAuthentication("cookieAuth");
        cookieAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //cookieAuth.setApiKeyPrefix("Token");

        // Create an instance of the API class
        ServerSettingsApi apiInstance = new ServerSettingsApi();

        try {
            Object result = apiInstance.configGetProxyManager();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ServerSettingsApi#configGetProxyManager");
            e.printStackTrace();
        }
    }
}
import 'package:openapi/api.dart';

final api_instance = DefaultApi();


try {
    final result = await api_instance.configGetProxyManager();
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->configGetProxyManager: $e\n');
}

import org.openapitools.client.api.ServerSettingsApi;

public class ServerSettingsApiExample {
    public static void main(String[] args) {
        ServerSettingsApi apiInstance = new ServerSettingsApi();

        try {
            Object result = apiInstance.configGetProxyManager();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ServerSettingsApi#configGetProxyManager");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: cookieAuth)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"domainflow_session"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"domainflow_session"];


// Create an instance of the API class
ServerSettingsApi *apiInstance = [[ServerSettingsApi alloc] init];

// Get proxy manager configuration
[apiInstance configGetProxyManagerWithCompletionHandler: 
              ^(Object output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var DomainFlowApi = require('domain_flow_api');
var defaultClient = DomainFlowApi.ApiClient.instance;

// Configure API key authorization: cookieAuth
var cookieAuth = defaultClient.authentications['cookieAuth'];
cookieAuth.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//cookieAuth.apiKeyPrefix['domainflow_session'] = "Token";

// Create an instance of the API class
var api = new DomainFlowApi.ServerSettingsApi()
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.configGetProxyManager(callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class configGetProxyManagerExample
    {
        public void main()
        {
            // Configure API key authorization: cookieAuth
            Configuration.Default.ApiKey.Add("domainflow_session", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("domainflow_session", "Bearer");

            // Create an instance of the API class
            var apiInstance = new ServerSettingsApi();

            try {
                // Get proxy manager configuration
                Object result = apiInstance.configGetProxyManager();
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling ServerSettingsApi.configGetProxyManager: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure API key authorization: cookieAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('domainflow_session', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('domainflow_session', 'Bearer');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\ServerSettingsApi();

try {
    $result = $api_instance->configGetProxyManager();
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling ServerSettingsApi->configGetProxyManager: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::ServerSettingsApi;

# Configure API key authorization: cookieAuth
$WWW::OPenAPIClient::Configuration::api_key->{'domainflow_session'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'domainflow_session'} = "Bearer";

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::ServerSettingsApi->new();

eval {
    my $result = $api_instance->configGetProxyManager();
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling ServerSettingsApi->configGetProxyManager: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure API key authorization: cookieAuth
openapi_client.configuration.api_key['domainflow_session'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['domainflow_session'] = 'Bearer'

# Create an instance of the API class
api_instance = openapi_client.ServerSettingsApi()

try:
    # Get proxy manager configuration
    api_response = api_instance.config_get_proxy_manager()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ServerSettingsApi->configGetProxyManager: %s\n" % e)
extern crate ServerSettingsApi;

pub fn main() {

    let mut context = ServerSettingsApi::Context::default();
    let result = client.configGetProxyManager(&context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Responses

Name Type Format Description
Retry-After Integer Seconds to wait before retrying


configGetRateLimiter

Get rate limiter configuration


/config/rate-limit

Usage and SDK Samples

curl -X GET \
 \
 -H "Accept: application/json" \
 "https://api.domainflow.dev/api/v2/config/rate-limit"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.ServerSettingsApi;

import java.io.File;
import java.util.*;

public class ServerSettingsApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure API key authorization: cookieAuth
        ApiKeyAuth cookieAuth = (ApiKeyAuth) defaultClient.getAuthentication("cookieAuth");
        cookieAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //cookieAuth.setApiKeyPrefix("Token");

        // Create an instance of the API class
        ServerSettingsApi apiInstance = new ServerSettingsApi();

        try {
            config_get_rate_limiter_200_response result = apiInstance.configGetRateLimiter();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ServerSettingsApi#configGetRateLimiter");
            e.printStackTrace();
        }
    }
}
import 'package:openapi/api.dart';

final api_instance = DefaultApi();


try {
    final result = await api_instance.configGetRateLimiter();
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->configGetRateLimiter: $e\n');
}

import org.openapitools.client.api.ServerSettingsApi;

public class ServerSettingsApiExample {
    public static void main(String[] args) {
        ServerSettingsApi apiInstance = new ServerSettingsApi();

        try {
            config_get_rate_limiter_200_response result = apiInstance.configGetRateLimiter();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ServerSettingsApi#configGetRateLimiter");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: cookieAuth)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"domainflow_session"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"domainflow_session"];


// Create an instance of the API class
ServerSettingsApi *apiInstance = [[ServerSettingsApi alloc] init];

// Get rate limiter configuration
[apiInstance configGetRateLimiterWithCompletionHandler: 
              ^(config_get_rate_limiter_200_response output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var DomainFlowApi = require('domain_flow_api');
var defaultClient = DomainFlowApi.ApiClient.instance;

// Configure API key authorization: cookieAuth
var cookieAuth = defaultClient.authentications['cookieAuth'];
cookieAuth.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//cookieAuth.apiKeyPrefix['domainflow_session'] = "Token";

// Create an instance of the API class
var api = new DomainFlowApi.ServerSettingsApi()
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.configGetRateLimiter(callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class configGetRateLimiterExample
    {
        public void main()
        {
            // Configure API key authorization: cookieAuth
            Configuration.Default.ApiKey.Add("domainflow_session", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("domainflow_session", "Bearer");

            // Create an instance of the API class
            var apiInstance = new ServerSettingsApi();

            try {
                // Get rate limiter configuration
                config_get_rate_limiter_200_response result = apiInstance.configGetRateLimiter();
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling ServerSettingsApi.configGetRateLimiter: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure API key authorization: cookieAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('domainflow_session', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('domainflow_session', 'Bearer');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\ServerSettingsApi();

try {
    $result = $api_instance->configGetRateLimiter();
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling ServerSettingsApi->configGetRateLimiter: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::ServerSettingsApi;

# Configure API key authorization: cookieAuth
$WWW::OPenAPIClient::Configuration::api_key->{'domainflow_session'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'domainflow_session'} = "Bearer";

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::ServerSettingsApi->new();

eval {
    my $result = $api_instance->configGetRateLimiter();
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling ServerSettingsApi->configGetRateLimiter: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure API key authorization: cookieAuth
openapi_client.configuration.api_key['domainflow_session'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['domainflow_session'] = 'Bearer'

# Create an instance of the API class
api_instance = openapi_client.ServerSettingsApi()

try:
    # Get rate limiter configuration
    api_response = api_instance.config_get_rate_limiter()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ServerSettingsApi->configGetRateLimiter: %s\n" % e)
extern crate ServerSettingsApi;

pub fn main() {

    let mut context = ServerSettingsApi::Context::default();
    let result = client.configGetRateLimiter(&context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Responses

Name Type Format Description
Retry-After Integer Seconds to wait before retrying


configGetServer

Get server configuration


/config/server

Usage and SDK Samples

curl -X GET \
 \
 -H "Accept: application/json" \
 "https://api.domainflow.dev/api/v2/config/server"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.ServerSettingsApi;

import java.io.File;
import java.util.*;

public class ServerSettingsApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure API key authorization: cookieAuth
        ApiKeyAuth cookieAuth = (ApiKeyAuth) defaultClient.getAuthentication("cookieAuth");
        cookieAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //cookieAuth.setApiKeyPrefix("Token");

        // Create an instance of the API class
        ServerSettingsApi apiInstance = new ServerSettingsApi();

        try {
            Object result = apiInstance.configGetServer();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ServerSettingsApi#configGetServer");
            e.printStackTrace();
        }
    }
}
import 'package:openapi/api.dart';

final api_instance = DefaultApi();


try {
    final result = await api_instance.configGetServer();
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->configGetServer: $e\n');
}

import org.openapitools.client.api.ServerSettingsApi;

public class ServerSettingsApiExample {
    public static void main(String[] args) {
        ServerSettingsApi apiInstance = new ServerSettingsApi();

        try {
            Object result = apiInstance.configGetServer();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ServerSettingsApi#configGetServer");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: cookieAuth)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"domainflow_session"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"domainflow_session"];


// Create an instance of the API class
ServerSettingsApi *apiInstance = [[ServerSettingsApi alloc] init];

// Get server configuration
[apiInstance configGetServerWithCompletionHandler: 
              ^(Object output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var DomainFlowApi = require('domain_flow_api');
var defaultClient = DomainFlowApi.ApiClient.instance;

// Configure API key authorization: cookieAuth
var cookieAuth = defaultClient.authentications['cookieAuth'];
cookieAuth.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//cookieAuth.apiKeyPrefix['domainflow_session'] = "Token";

// Create an instance of the API class
var api = new DomainFlowApi.ServerSettingsApi()
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.configGetServer(callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class configGetServerExample
    {
        public void main()
        {
            // Configure API key authorization: cookieAuth
            Configuration.Default.ApiKey.Add("domainflow_session", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("domainflow_session", "Bearer");

            // Create an instance of the API class
            var apiInstance = new ServerSettingsApi();

            try {
                // Get server configuration
                Object result = apiInstance.configGetServer();
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling ServerSettingsApi.configGetServer: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure API key authorization: cookieAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('domainflow_session', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('domainflow_session', 'Bearer');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\ServerSettingsApi();

try {
    $result = $api_instance->configGetServer();
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling ServerSettingsApi->configGetServer: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::ServerSettingsApi;

# Configure API key authorization: cookieAuth
$WWW::OPenAPIClient::Configuration::api_key->{'domainflow_session'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'domainflow_session'} = "Bearer";

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::ServerSettingsApi->new();

eval {
    my $result = $api_instance->configGetServer();
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling ServerSettingsApi->configGetServer: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure API key authorization: cookieAuth
openapi_client.configuration.api_key['domainflow_session'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['domainflow_session'] = 'Bearer'

# Create an instance of the API class
api_instance = openapi_client.ServerSettingsApi()

try:
    # Get server configuration
    api_response = api_instance.config_get_server()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ServerSettingsApi->configGetServer: %s\n" % e)
extern crate ServerSettingsApi;

pub fn main() {

    let mut context = ServerSettingsApi::Context::default();
    let result = client.configGetServer(&context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Responses

Name Type Format Description
Retry-After Integer Seconds to wait before retrying


configGetStealth

Get stealth configuration


/config/stealth

Usage and SDK Samples

curl -X GET \
 \
 -H "Accept: application/json" \
 "https://api.domainflow.dev/api/v2/config/stealth"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.ServerSettingsApi;

import java.io.File;
import java.util.*;

public class ServerSettingsApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure API key authorization: cookieAuth
        ApiKeyAuth cookieAuth = (ApiKeyAuth) defaultClient.getAuthentication("cookieAuth");
        cookieAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //cookieAuth.setApiKeyPrefix("Token");

        // Create an instance of the API class
        ServerSettingsApi apiInstance = new ServerSettingsApi();

        try {
            config_get_stealth_200_response result = apiInstance.configGetStealth();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ServerSettingsApi#configGetStealth");
            e.printStackTrace();
        }
    }
}
import 'package:openapi/api.dart';

final api_instance = DefaultApi();


try {
    final result = await api_instance.configGetStealth();
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->configGetStealth: $e\n');
}

import org.openapitools.client.api.ServerSettingsApi;

public class ServerSettingsApiExample {
    public static void main(String[] args) {
        ServerSettingsApi apiInstance = new ServerSettingsApi();

        try {
            config_get_stealth_200_response result = apiInstance.configGetStealth();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ServerSettingsApi#configGetStealth");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: cookieAuth)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"domainflow_session"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"domainflow_session"];


// Create an instance of the API class
ServerSettingsApi *apiInstance = [[ServerSettingsApi alloc] init];

// Get stealth configuration
[apiInstance configGetStealthWithCompletionHandler: 
              ^(config_get_stealth_200_response output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var DomainFlowApi = require('domain_flow_api');
var defaultClient = DomainFlowApi.ApiClient.instance;

// Configure API key authorization: cookieAuth
var cookieAuth = defaultClient.authentications['cookieAuth'];
cookieAuth.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//cookieAuth.apiKeyPrefix['domainflow_session'] = "Token";

// Create an instance of the API class
var api = new DomainFlowApi.ServerSettingsApi()
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.configGetStealth(callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class configGetStealthExample
    {
        public void main()
        {
            // Configure API key authorization: cookieAuth
            Configuration.Default.ApiKey.Add("domainflow_session", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("domainflow_session", "Bearer");

            // Create an instance of the API class
            var apiInstance = new ServerSettingsApi();

            try {
                // Get stealth configuration
                config_get_stealth_200_response result = apiInstance.configGetStealth();
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling ServerSettingsApi.configGetStealth: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure API key authorization: cookieAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('domainflow_session', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('domainflow_session', 'Bearer');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\ServerSettingsApi();

try {
    $result = $api_instance->configGetStealth();
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling ServerSettingsApi->configGetStealth: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::ServerSettingsApi;

# Configure API key authorization: cookieAuth
$WWW::OPenAPIClient::Configuration::api_key->{'domainflow_session'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'domainflow_session'} = "Bearer";

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::ServerSettingsApi->new();

eval {
    my $result = $api_instance->configGetStealth();
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling ServerSettingsApi->configGetStealth: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure API key authorization: cookieAuth
openapi_client.configuration.api_key['domainflow_session'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['domainflow_session'] = 'Bearer'

# Create an instance of the API class
api_instance = openapi_client.ServerSettingsApi()

try:
    # Get stealth configuration
    api_response = api_instance.config_get_stealth()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ServerSettingsApi->configGetStealth: %s\n" % e)
extern crate ServerSettingsApi;

pub fn main() {

    let mut context = ServerSettingsApi::Context::default();
    let result = client.configGetStealth(&context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Responses


configGetWorker

Get worker configuration


/config/worker

Usage and SDK Samples

curl -X GET \
 \
 -H "Accept: application/json" \
 "https://api.domainflow.dev/api/v2/config/worker"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.ServerSettingsApi;

import java.io.File;
import java.util.*;

public class ServerSettingsApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure API key authorization: cookieAuth
        ApiKeyAuth cookieAuth = (ApiKeyAuth) defaultClient.getAuthentication("cookieAuth");
        cookieAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //cookieAuth.setApiKeyPrefix("Token");

        // Create an instance of the API class
        ServerSettingsApi apiInstance = new ServerSettingsApi();

        try {
            config_get_worker_200_response result = apiInstance.configGetWorker();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ServerSettingsApi#configGetWorker");
            e.printStackTrace();
        }
    }
}
import 'package:openapi/api.dart';

final api_instance = DefaultApi();


try {
    final result = await api_instance.configGetWorker();
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->configGetWorker: $e\n');
}

import org.openapitools.client.api.ServerSettingsApi;

public class ServerSettingsApiExample {
    public static void main(String[] args) {
        ServerSettingsApi apiInstance = new ServerSettingsApi();

        try {
            config_get_worker_200_response result = apiInstance.configGetWorker();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ServerSettingsApi#configGetWorker");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: cookieAuth)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"domainflow_session"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"domainflow_session"];


// Create an instance of the API class
ServerSettingsApi *apiInstance = [[ServerSettingsApi alloc] init];

// Get worker configuration
[apiInstance configGetWorkerWithCompletionHandler: 
              ^(config_get_worker_200_response output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var DomainFlowApi = require('domain_flow_api');
var defaultClient = DomainFlowApi.ApiClient.instance;

// Configure API key authorization: cookieAuth
var cookieAuth = defaultClient.authentications['cookieAuth'];
cookieAuth.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//cookieAuth.apiKeyPrefix['domainflow_session'] = "Token";

// Create an instance of the API class
var api = new DomainFlowApi.ServerSettingsApi()
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.configGetWorker(callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class configGetWorkerExample
    {
        public void main()
        {
            // Configure API key authorization: cookieAuth
            Configuration.Default.ApiKey.Add("domainflow_session", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("domainflow_session", "Bearer");

            // Create an instance of the API class
            var apiInstance = new ServerSettingsApi();

            try {
                // Get worker configuration
                config_get_worker_200_response result = apiInstance.configGetWorker();
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling ServerSettingsApi.configGetWorker: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure API key authorization: cookieAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('domainflow_session', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('domainflow_session', 'Bearer');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\ServerSettingsApi();

try {
    $result = $api_instance->configGetWorker();
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling ServerSettingsApi->configGetWorker: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::ServerSettingsApi;

# Configure API key authorization: cookieAuth
$WWW::OPenAPIClient::Configuration::api_key->{'domainflow_session'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'domainflow_session'} = "Bearer";

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::ServerSettingsApi->new();

eval {
    my $result = $api_instance->configGetWorker();
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling ServerSettingsApi->configGetWorker: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure API key authorization: cookieAuth
openapi_client.configuration.api_key['domainflow_session'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['domainflow_session'] = 'Bearer'

# Create an instance of the API class
api_instance = openapi_client.ServerSettingsApi()

try:
    # Get worker configuration
    api_response = api_instance.config_get_worker()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ServerSettingsApi->configGetWorker: %s\n" % e)
extern crate ServerSettingsApi;

pub fn main() {

    let mut context = ServerSettingsApi::Context::default();
    let result = client.configGetWorker(&context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Responses

Name Type Format Description
Retry-After Integer Seconds to wait before retrying


configUpdateAuth

Update authentication configuration


/config/auth

Usage and SDK Samples

curl -X PUT \
 \
 -H "Accept: application/json" \
 -H "Content-Type: application/json" \
 "https://api.domainflow.dev/api/v2/config/auth" \
 -d ''
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.ServerSettingsApi;

import java.io.File;
import java.util.*;

public class ServerSettingsApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure API key authorization: cookieAuth
        ApiKeyAuth cookieAuth = (ApiKeyAuth) defaultClient.getAuthentication("cookieAuth");
        cookieAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //cookieAuth.setApiKeyPrefix("Token");

        // Create an instance of the API class
        ServerSettingsApi apiInstance = new ServerSettingsApi();
        map[String, oas_any_type_not_mapped] requestBody = Object; // map[String, oas_any_type_not_mapped] | 

        try {
            config_get_auth_200_response result = apiInstance.configUpdateAuth(requestBody);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ServerSettingsApi#configUpdateAuth");
            e.printStackTrace();
        }
    }
}
import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final map[String, oas_any_type_not_mapped] requestBody = new map[String, oas_any_type_not_mapped](); // map[String, oas_any_type_not_mapped] | 

try {
    final result = await api_instance.configUpdateAuth(requestBody);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->configUpdateAuth: $e\n');
}

import org.openapitools.client.api.ServerSettingsApi;

public class ServerSettingsApiExample {
    public static void main(String[] args) {
        ServerSettingsApi apiInstance = new ServerSettingsApi();
        map[String, oas_any_type_not_mapped] requestBody = Object; // map[String, oas_any_type_not_mapped] | 

        try {
            config_get_auth_200_response result = apiInstance.configUpdateAuth(requestBody);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ServerSettingsApi#configUpdateAuth");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: cookieAuth)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"domainflow_session"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"domainflow_session"];


// Create an instance of the API class
ServerSettingsApi *apiInstance = [[ServerSettingsApi alloc] init];
map[String, oas_any_type_not_mapped] *requestBody = Object; // 

// Update authentication configuration
[apiInstance configUpdateAuthWith:requestBody
              completionHandler: ^(config_get_auth_200_response output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var DomainFlowApi = require('domain_flow_api');
var defaultClient = DomainFlowApi.ApiClient.instance;

// Configure API key authorization: cookieAuth
var cookieAuth = defaultClient.authentications['cookieAuth'];
cookieAuth.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//cookieAuth.apiKeyPrefix['domainflow_session'] = "Token";

// Create an instance of the API class
var api = new DomainFlowApi.ServerSettingsApi()
var requestBody = Object; // {map[String, oas_any_type_not_mapped]} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.configUpdateAuth(requestBody, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class configUpdateAuthExample
    {
        public void main()
        {
            // Configure API key authorization: cookieAuth
            Configuration.Default.ApiKey.Add("domainflow_session", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("domainflow_session", "Bearer");

            // Create an instance of the API class
            var apiInstance = new ServerSettingsApi();
            var requestBody = new map[String, oas_any_type_not_mapped](); // map[String, oas_any_type_not_mapped] | 

            try {
                // Update authentication configuration
                config_get_auth_200_response result = apiInstance.configUpdateAuth(requestBody);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling ServerSettingsApi.configUpdateAuth: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure API key authorization: cookieAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('domainflow_session', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('domainflow_session', 'Bearer');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\ServerSettingsApi();
$requestBody = Object; // map[String, oas_any_type_not_mapped] | 

try {
    $result = $api_instance->configUpdateAuth($requestBody);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling ServerSettingsApi->configUpdateAuth: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::ServerSettingsApi;

# Configure API key authorization: cookieAuth
$WWW::OPenAPIClient::Configuration::api_key->{'domainflow_session'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'domainflow_session'} = "Bearer";

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::ServerSettingsApi->new();
my $requestBody = WWW::OPenAPIClient::Object::map[String, oas_any_type_not_mapped]->new(); # map[String, oas_any_type_not_mapped] | 

eval {
    my $result = $api_instance->configUpdateAuth(requestBody => $requestBody);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling ServerSettingsApi->configUpdateAuth: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure API key authorization: cookieAuth
openapi_client.configuration.api_key['domainflow_session'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['domainflow_session'] = 'Bearer'

# Create an instance of the API class
api_instance = openapi_client.ServerSettingsApi()
requestBody = Object # map[String, oas_any_type_not_mapped] | 

try:
    # Update authentication configuration
    api_response = api_instance.config_update_auth(requestBody)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ServerSettingsApi->configUpdateAuth: %s\n" % e)
extern crate ServerSettingsApi;

pub fn main() {
    let requestBody = Object; // map[String, oas_any_type_not_mapped]

    let mut context = ServerSettingsApi::Context::default();
    let result = client.configUpdateAuth(requestBody, &context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Body parameters
Name Description
requestBody *

Responses

Name Type Format Description
Retry-After Integer Seconds to wait before retrying


configUpdateDns

Update DNS configuration


/config/dns

Usage and SDK Samples

curl -X PUT \
 \
 -H "Accept: application/json" \
 -H "Content-Type: application/json" \
 "https://api.domainflow.dev/api/v2/config/dns" \
 -d ''
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.ServerSettingsApi;

import java.io.File;
import java.util.*;

public class ServerSettingsApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure API key authorization: cookieAuth
        ApiKeyAuth cookieAuth = (ApiKeyAuth) defaultClient.getAuthentication("cookieAuth");
        cookieAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //cookieAuth.setApiKeyPrefix("Token");

        // Create an instance of the API class
        ServerSettingsApi apiInstance = new ServerSettingsApi();
        map[String, oas_any_type_not_mapped] requestBody = Object; // map[String, oas_any_type_not_mapped] | 

        try {
            config_get_dns_200_response result = apiInstance.configUpdateDns(requestBody);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ServerSettingsApi#configUpdateDns");
            e.printStackTrace();
        }
    }
}
import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final map[String, oas_any_type_not_mapped] requestBody = new map[String, oas_any_type_not_mapped](); // map[String, oas_any_type_not_mapped] | 

try {
    final result = await api_instance.configUpdateDns(requestBody);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->configUpdateDns: $e\n');
}

import org.openapitools.client.api.ServerSettingsApi;

public class ServerSettingsApiExample {
    public static void main(String[] args) {
        ServerSettingsApi apiInstance = new ServerSettingsApi();
        map[String, oas_any_type_not_mapped] requestBody = Object; // map[String, oas_any_type_not_mapped] | 

        try {
            config_get_dns_200_response result = apiInstance.configUpdateDns(requestBody);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ServerSettingsApi#configUpdateDns");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: cookieAuth)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"domainflow_session"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"domainflow_session"];


// Create an instance of the API class
ServerSettingsApi *apiInstance = [[ServerSettingsApi alloc] init];
map[String, oas_any_type_not_mapped] *requestBody = Object; // 

// Update DNS configuration
[apiInstance configUpdateDnsWith:requestBody
              completionHandler: ^(config_get_dns_200_response output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var DomainFlowApi = require('domain_flow_api');
var defaultClient = DomainFlowApi.ApiClient.instance;

// Configure API key authorization: cookieAuth
var cookieAuth = defaultClient.authentications['cookieAuth'];
cookieAuth.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//cookieAuth.apiKeyPrefix['domainflow_session'] = "Token";

// Create an instance of the API class
var api = new DomainFlowApi.ServerSettingsApi()
var requestBody = Object; // {map[String, oas_any_type_not_mapped]} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.configUpdateDns(requestBody, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class configUpdateDnsExample
    {
        public void main()
        {
            // Configure API key authorization: cookieAuth
            Configuration.Default.ApiKey.Add("domainflow_session", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("domainflow_session", "Bearer");

            // Create an instance of the API class
            var apiInstance = new ServerSettingsApi();
            var requestBody = new map[String, oas_any_type_not_mapped](); // map[String, oas_any_type_not_mapped] | 

            try {
                // Update DNS configuration
                config_get_dns_200_response result = apiInstance.configUpdateDns(requestBody);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling ServerSettingsApi.configUpdateDns: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure API key authorization: cookieAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('domainflow_session', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('domainflow_session', 'Bearer');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\ServerSettingsApi();
$requestBody = Object; // map[String, oas_any_type_not_mapped] | 

try {
    $result = $api_instance->configUpdateDns($requestBody);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling ServerSettingsApi->configUpdateDns: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::ServerSettingsApi;

# Configure API key authorization: cookieAuth
$WWW::OPenAPIClient::Configuration::api_key->{'domainflow_session'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'domainflow_session'} = "Bearer";

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::ServerSettingsApi->new();
my $requestBody = WWW::OPenAPIClient::Object::map[String, oas_any_type_not_mapped]->new(); # map[String, oas_any_type_not_mapped] | 

eval {
    my $result = $api_instance->configUpdateDns(requestBody => $requestBody);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling ServerSettingsApi->configUpdateDns: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure API key authorization: cookieAuth
openapi_client.configuration.api_key['domainflow_session'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['domainflow_session'] = 'Bearer'

# Create an instance of the API class
api_instance = openapi_client.ServerSettingsApi()
requestBody = Object # map[String, oas_any_type_not_mapped] | 

try:
    # Update DNS configuration
    api_response = api_instance.config_update_dns(requestBody)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ServerSettingsApi->configUpdateDns: %s\n" % e)
extern crate ServerSettingsApi;

pub fn main() {
    let requestBody = Object; // map[String, oas_any_type_not_mapped]

    let mut context = ServerSettingsApi::Context::default();
    let result = client.configUpdateDns(requestBody, &context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Body parameters
Name Description
requestBody *

Responses

Name Type Format Description
Retry-After Integer Seconds to wait before retrying


configUpdateHttp

Update HTTP configuration


/config/http

Usage and SDK Samples

curl -X PUT \
 \
 -H "Accept: application/json" \
 -H "Content-Type: application/json" \
 "https://api.domainflow.dev/api/v2/config/http" \
 -d ''
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.ServerSettingsApi;

import java.io.File;
import java.util.*;

public class ServerSettingsApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure API key authorization: cookieAuth
        ApiKeyAuth cookieAuth = (ApiKeyAuth) defaultClient.getAuthentication("cookieAuth");
        cookieAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //cookieAuth.setApiKeyPrefix("Token");

        // Create an instance of the API class
        ServerSettingsApi apiInstance = new ServerSettingsApi();
        Object body = Object; // Object | 

        try {
            Object result = apiInstance.configUpdateHttp(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ServerSettingsApi#configUpdateHttp");
            e.printStackTrace();
        }
    }
}
import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final Object body = new Object(); // Object | 

try {
    final result = await api_instance.configUpdateHttp(body);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->configUpdateHttp: $e\n');
}

import org.openapitools.client.api.ServerSettingsApi;

public class ServerSettingsApiExample {
    public static void main(String[] args) {
        ServerSettingsApi apiInstance = new ServerSettingsApi();
        Object body = Object; // Object | 

        try {
            Object result = apiInstance.configUpdateHttp(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ServerSettingsApi#configUpdateHttp");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: cookieAuth)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"domainflow_session"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"domainflow_session"];


// Create an instance of the API class
ServerSettingsApi *apiInstance = [[ServerSettingsApi alloc] init];
Object *body = Object; // 

// Update HTTP configuration
[apiInstance configUpdateHttpWith:body
              completionHandler: ^(Object output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var DomainFlowApi = require('domain_flow_api');
var defaultClient = DomainFlowApi.ApiClient.instance;

// Configure API key authorization: cookieAuth
var cookieAuth = defaultClient.authentications['cookieAuth'];
cookieAuth.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//cookieAuth.apiKeyPrefix['domainflow_session'] = "Token";

// Create an instance of the API class
var api = new DomainFlowApi.ServerSettingsApi()
var body = Object; // {Object} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.configUpdateHttp(body, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class configUpdateHttpExample
    {
        public void main()
        {
            // Configure API key authorization: cookieAuth
            Configuration.Default.ApiKey.Add("domainflow_session", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("domainflow_session", "Bearer");

            // Create an instance of the API class
            var apiInstance = new ServerSettingsApi();
            var body = Object;  // Object | 

            try {
                // Update HTTP configuration
                Object result = apiInstance.configUpdateHttp(body);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling ServerSettingsApi.configUpdateHttp: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure API key authorization: cookieAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('domainflow_session', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('domainflow_session', 'Bearer');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\ServerSettingsApi();
$body = Object; // Object | 

try {
    $result = $api_instance->configUpdateHttp($body);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling ServerSettingsApi->configUpdateHttp: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::ServerSettingsApi;

# Configure API key authorization: cookieAuth
$WWW::OPenAPIClient::Configuration::api_key->{'domainflow_session'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'domainflow_session'} = "Bearer";

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::ServerSettingsApi->new();
my $body = WWW::OPenAPIClient::Object::Object->new(); # Object | 

eval {
    my $result = $api_instance->configUpdateHttp(body => $body);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling ServerSettingsApi->configUpdateHttp: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure API key authorization: cookieAuth
openapi_client.configuration.api_key['domainflow_session'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['domainflow_session'] = 'Bearer'

# Create an instance of the API class
api_instance = openapi_client.ServerSettingsApi()
body = Object # Object | 

try:
    # Update HTTP configuration
    api_response = api_instance.config_update_http(body)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ServerSettingsApi->configUpdateHttp: %s\n" % e)
extern crate ServerSettingsApi;

pub fn main() {
    let body = Object; // Object

    let mut context = ServerSettingsApi::Context::default();
    let result = client.configUpdateHttp(body, &context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Body parameters
Name Description
body *

Responses

Name Type Format Description
Retry-After Integer Seconds to wait before retrying


configUpdateLogging

Update logging configuration


/config/logging

Usage and SDK Samples

curl -X PUT \
 \
 -H "Accept: application/json" \
 -H "Content-Type: application/json" \
 "https://api.domainflow.dev/api/v2/config/logging" \
 -d ''
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.ServerSettingsApi;

import java.io.File;
import java.util.*;

public class ServerSettingsApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure API key authorization: cookieAuth
        ApiKeyAuth cookieAuth = (ApiKeyAuth) defaultClient.getAuthentication("cookieAuth");
        cookieAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //cookieAuth.setApiKeyPrefix("Token");

        // Create an instance of the API class
        ServerSettingsApi apiInstance = new ServerSettingsApi();
        map[String, oas_any_type_not_mapped] requestBody = Object; // map[String, oas_any_type_not_mapped] | 

        try {
            config_get_logging_200_response result = apiInstance.configUpdateLogging(requestBody);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ServerSettingsApi#configUpdateLogging");
            e.printStackTrace();
        }
    }
}
import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final map[String, oas_any_type_not_mapped] requestBody = new map[String, oas_any_type_not_mapped](); // map[String, oas_any_type_not_mapped] | 

try {
    final result = await api_instance.configUpdateLogging(requestBody);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->configUpdateLogging: $e\n');
}

import org.openapitools.client.api.ServerSettingsApi;

public class ServerSettingsApiExample {
    public static void main(String[] args) {
        ServerSettingsApi apiInstance = new ServerSettingsApi();
        map[String, oas_any_type_not_mapped] requestBody = Object; // map[String, oas_any_type_not_mapped] | 

        try {
            config_get_logging_200_response result = apiInstance.configUpdateLogging(requestBody);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ServerSettingsApi#configUpdateLogging");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: cookieAuth)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"domainflow_session"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"domainflow_session"];


// Create an instance of the API class
ServerSettingsApi *apiInstance = [[ServerSettingsApi alloc] init];
map[String, oas_any_type_not_mapped] *requestBody = Object; // 

// Update logging configuration
[apiInstance configUpdateLoggingWith:requestBody
              completionHandler: ^(config_get_logging_200_response output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var DomainFlowApi = require('domain_flow_api');
var defaultClient = DomainFlowApi.ApiClient.instance;

// Configure API key authorization: cookieAuth
var cookieAuth = defaultClient.authentications['cookieAuth'];
cookieAuth.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//cookieAuth.apiKeyPrefix['domainflow_session'] = "Token";

// Create an instance of the API class
var api = new DomainFlowApi.ServerSettingsApi()
var requestBody = Object; // {map[String, oas_any_type_not_mapped]} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.configUpdateLogging(requestBody, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class configUpdateLoggingExample
    {
        public void main()
        {
            // Configure API key authorization: cookieAuth
            Configuration.Default.ApiKey.Add("domainflow_session", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("domainflow_session", "Bearer");

            // Create an instance of the API class
            var apiInstance = new ServerSettingsApi();
            var requestBody = new map[String, oas_any_type_not_mapped](); // map[String, oas_any_type_not_mapped] | 

            try {
                // Update logging configuration
                config_get_logging_200_response result = apiInstance.configUpdateLogging(requestBody);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling ServerSettingsApi.configUpdateLogging: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure API key authorization: cookieAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('domainflow_session', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('domainflow_session', 'Bearer');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\ServerSettingsApi();
$requestBody = Object; // map[String, oas_any_type_not_mapped] | 

try {
    $result = $api_instance->configUpdateLogging($requestBody);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling ServerSettingsApi->configUpdateLogging: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::ServerSettingsApi;

# Configure API key authorization: cookieAuth
$WWW::OPenAPIClient::Configuration::api_key->{'domainflow_session'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'domainflow_session'} = "Bearer";

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::ServerSettingsApi->new();
my $requestBody = WWW::OPenAPIClient::Object::map[String, oas_any_type_not_mapped]->new(); # map[String, oas_any_type_not_mapped] | 

eval {
    my $result = $api_instance->configUpdateLogging(requestBody => $requestBody);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling ServerSettingsApi->configUpdateLogging: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure API key authorization: cookieAuth
openapi_client.configuration.api_key['domainflow_session'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['domainflow_session'] = 'Bearer'

# Create an instance of the API class
api_instance = openapi_client.ServerSettingsApi()
requestBody = Object # map[String, oas_any_type_not_mapped] | 

try:
    # Update logging configuration
    api_response = api_instance.config_update_logging(requestBody)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ServerSettingsApi->configUpdateLogging: %s\n" % e)
extern crate ServerSettingsApi;

pub fn main() {
    let requestBody = Object; // map[String, oas_any_type_not_mapped]

    let mut context = ServerSettingsApi::Context::default();
    let result = client.configUpdateLogging(requestBody, &context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Body parameters
Name Description
requestBody *

Responses

Name Type Format Description
Retry-After Integer Seconds to wait before retrying


configUpdateProxyManager

Update proxy manager configuration


/config/proxy-manager

Usage and SDK Samples

curl -X PUT \
 \
 -H "Accept: application/json" \
 -H "Content-Type: application/json" \
 "https://api.domainflow.dev/api/v2/config/proxy-manager" \
 -d ''
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.ServerSettingsApi;

import java.io.File;
import java.util.*;

public class ServerSettingsApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure API key authorization: cookieAuth
        ApiKeyAuth cookieAuth = (ApiKeyAuth) defaultClient.getAuthentication("cookieAuth");
        cookieAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //cookieAuth.setApiKeyPrefix("Token");

        // Create an instance of the API class
        ServerSettingsApi apiInstance = new ServerSettingsApi();
        Object body = Object; // Object | 

        try {
            Object result = apiInstance.configUpdateProxyManager(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ServerSettingsApi#configUpdateProxyManager");
            e.printStackTrace();
        }
    }
}
import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final Object body = new Object(); // Object | 

try {
    final result = await api_instance.configUpdateProxyManager(body);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->configUpdateProxyManager: $e\n');
}

import org.openapitools.client.api.ServerSettingsApi;

public class ServerSettingsApiExample {
    public static void main(String[] args) {
        ServerSettingsApi apiInstance = new ServerSettingsApi();
        Object body = Object; // Object | 

        try {
            Object result = apiInstance.configUpdateProxyManager(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ServerSettingsApi#configUpdateProxyManager");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: cookieAuth)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"domainflow_session"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"domainflow_session"];


// Create an instance of the API class
ServerSettingsApi *apiInstance = [[ServerSettingsApi alloc] init];
Object *body = Object; // 

// Update proxy manager configuration
[apiInstance configUpdateProxyManagerWith:body
              completionHandler: ^(Object output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var DomainFlowApi = require('domain_flow_api');
var defaultClient = DomainFlowApi.ApiClient.instance;

// Configure API key authorization: cookieAuth
var cookieAuth = defaultClient.authentications['cookieAuth'];
cookieAuth.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//cookieAuth.apiKeyPrefix['domainflow_session'] = "Token";

// Create an instance of the API class
var api = new DomainFlowApi.ServerSettingsApi()
var body = Object; // {Object} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.configUpdateProxyManager(body, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class configUpdateProxyManagerExample
    {
        public void main()
        {
            // Configure API key authorization: cookieAuth
            Configuration.Default.ApiKey.Add("domainflow_session", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("domainflow_session", "Bearer");

            // Create an instance of the API class
            var apiInstance = new ServerSettingsApi();
            var body = Object;  // Object | 

            try {
                // Update proxy manager configuration
                Object result = apiInstance.configUpdateProxyManager(body);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling ServerSettingsApi.configUpdateProxyManager: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure API key authorization: cookieAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('domainflow_session', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('domainflow_session', 'Bearer');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\ServerSettingsApi();
$body = Object; // Object | 

try {
    $result = $api_instance->configUpdateProxyManager($body);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling ServerSettingsApi->configUpdateProxyManager: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::ServerSettingsApi;

# Configure API key authorization: cookieAuth
$WWW::OPenAPIClient::Configuration::api_key->{'domainflow_session'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'domainflow_session'} = "Bearer";

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::ServerSettingsApi->new();
my $body = WWW::OPenAPIClient::Object::Object->new(); # Object | 

eval {
    my $result = $api_instance->configUpdateProxyManager(body => $body);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling ServerSettingsApi->configUpdateProxyManager: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure API key authorization: cookieAuth
openapi_client.configuration.api_key['domainflow_session'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['domainflow_session'] = 'Bearer'

# Create an instance of the API class
api_instance = openapi_client.ServerSettingsApi()
body = Object # Object | 

try:
    # Update proxy manager configuration
    api_response = api_instance.config_update_proxy_manager(body)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ServerSettingsApi->configUpdateProxyManager: %s\n" % e)
extern crate ServerSettingsApi;

pub fn main() {
    let body = Object; // Object

    let mut context = ServerSettingsApi::Context::default();
    let result = client.configUpdateProxyManager(body, &context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Body parameters
Name Description
body *

Responses

Name Type Format Description
Retry-After Integer Seconds to wait before retrying


configUpdateRateLimiter

Update rate limiter configuration


/config/rate-limit

Usage and SDK Samples

curl -X PUT \
 \
 -H "Accept: application/json" \
 -H "Content-Type: application/json" \
 "https://api.domainflow.dev/api/v2/config/rate-limit" \
 -d ''
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.ServerSettingsApi;

import java.io.File;
import java.util.*;

public class ServerSettingsApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure API key authorization: cookieAuth
        ApiKeyAuth cookieAuth = (ApiKeyAuth) defaultClient.getAuthentication("cookieAuth");
        cookieAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //cookieAuth.setApiKeyPrefix("Token");

        // Create an instance of the API class
        ServerSettingsApi apiInstance = new ServerSettingsApi();
        map[String, oas_any_type_not_mapped] requestBody = Object; // map[String, oas_any_type_not_mapped] | 

        try {
            config_get_rate_limiter_200_response result = apiInstance.configUpdateRateLimiter(requestBody);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ServerSettingsApi#configUpdateRateLimiter");
            e.printStackTrace();
        }
    }
}
import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final map[String, oas_any_type_not_mapped] requestBody = new map[String, oas_any_type_not_mapped](); // map[String, oas_any_type_not_mapped] | 

try {
    final result = await api_instance.configUpdateRateLimiter(requestBody);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->configUpdateRateLimiter: $e\n');
}

import org.openapitools.client.api.ServerSettingsApi;

public class ServerSettingsApiExample {
    public static void main(String[] args) {
        ServerSettingsApi apiInstance = new ServerSettingsApi();
        map[String, oas_any_type_not_mapped] requestBody = Object; // map[String, oas_any_type_not_mapped] | 

        try {
            config_get_rate_limiter_200_response result = apiInstance.configUpdateRateLimiter(requestBody);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ServerSettingsApi#configUpdateRateLimiter");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: cookieAuth)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"domainflow_session"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"domainflow_session"];


// Create an instance of the API class
ServerSettingsApi *apiInstance = [[ServerSettingsApi alloc] init];
map[String, oas_any_type_not_mapped] *requestBody = Object; // 

// Update rate limiter configuration
[apiInstance configUpdateRateLimiterWith:requestBody
              completionHandler: ^(config_get_rate_limiter_200_response output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var DomainFlowApi = require('domain_flow_api');
var defaultClient = DomainFlowApi.ApiClient.instance;

// Configure API key authorization: cookieAuth
var cookieAuth = defaultClient.authentications['cookieAuth'];
cookieAuth.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//cookieAuth.apiKeyPrefix['domainflow_session'] = "Token";

// Create an instance of the API class
var api = new DomainFlowApi.ServerSettingsApi()
var requestBody = Object; // {map[String, oas_any_type_not_mapped]} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.configUpdateRateLimiter(requestBody, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class configUpdateRateLimiterExample
    {
        public void main()
        {
            // Configure API key authorization: cookieAuth
            Configuration.Default.ApiKey.Add("domainflow_session", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("domainflow_session", "Bearer");

            // Create an instance of the API class
            var apiInstance = new ServerSettingsApi();
            var requestBody = new map[String, oas_any_type_not_mapped](); // map[String, oas_any_type_not_mapped] | 

            try {
                // Update rate limiter configuration
                config_get_rate_limiter_200_response result = apiInstance.configUpdateRateLimiter(requestBody);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling ServerSettingsApi.configUpdateRateLimiter: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure API key authorization: cookieAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('domainflow_session', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('domainflow_session', 'Bearer');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\ServerSettingsApi();
$requestBody = Object; // map[String, oas_any_type_not_mapped] | 

try {
    $result = $api_instance->configUpdateRateLimiter($requestBody);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling ServerSettingsApi->configUpdateRateLimiter: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::ServerSettingsApi;

# Configure API key authorization: cookieAuth
$WWW::OPenAPIClient::Configuration::api_key->{'domainflow_session'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'domainflow_session'} = "Bearer";

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::ServerSettingsApi->new();
my $requestBody = WWW::OPenAPIClient::Object::map[String, oas_any_type_not_mapped]->new(); # map[String, oas_any_type_not_mapped] | 

eval {
    my $result = $api_instance->configUpdateRateLimiter(requestBody => $requestBody);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling ServerSettingsApi->configUpdateRateLimiter: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure API key authorization: cookieAuth
openapi_client.configuration.api_key['domainflow_session'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['domainflow_session'] = 'Bearer'

# Create an instance of the API class
api_instance = openapi_client.ServerSettingsApi()
requestBody = Object # map[String, oas_any_type_not_mapped] | 

try:
    # Update rate limiter configuration
    api_response = api_instance.config_update_rate_limiter(requestBody)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ServerSettingsApi->configUpdateRateLimiter: %s\n" % e)
extern crate ServerSettingsApi;

pub fn main() {
    let requestBody = Object; // map[String, oas_any_type_not_mapped]

    let mut context = ServerSettingsApi::Context::default();
    let result = client.configUpdateRateLimiter(requestBody, &context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Body parameters
Name Description
requestBody *

Responses

Name Type Format Description
Retry-After Integer Seconds to wait before retrying


configUpdateServer

Update server configuration


/config/server

Usage and SDK Samples

curl -X PUT \
 \
 -H "Accept: application/json" \
 -H "Content-Type: application/json" \
 "https://api.domainflow.dev/api/v2/config/server" \
 -d ''
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.ServerSettingsApi;

import java.io.File;
import java.util.*;

public class ServerSettingsApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure API key authorization: cookieAuth
        ApiKeyAuth cookieAuth = (ApiKeyAuth) defaultClient.getAuthentication("cookieAuth");
        cookieAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //cookieAuth.setApiKeyPrefix("Token");

        // Create an instance of the API class
        ServerSettingsApi apiInstance = new ServerSettingsApi();
        Object body = Object; // Object | 

        try {
            Object result = apiInstance.configUpdateServer(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ServerSettingsApi#configUpdateServer");
            e.printStackTrace();
        }
    }
}
import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final Object body = new Object(); // Object | 

try {
    final result = await api_instance.configUpdateServer(body);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->configUpdateServer: $e\n');
}

import org.openapitools.client.api.ServerSettingsApi;

public class ServerSettingsApiExample {
    public static void main(String[] args) {
        ServerSettingsApi apiInstance = new ServerSettingsApi();
        Object body = Object; // Object | 

        try {
            Object result = apiInstance.configUpdateServer(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ServerSettingsApi#configUpdateServer");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: cookieAuth)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"domainflow_session"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"domainflow_session"];


// Create an instance of the API class
ServerSettingsApi *apiInstance = [[ServerSettingsApi alloc] init];
Object *body = Object; // 

// Update server configuration
[apiInstance configUpdateServerWith:body
              completionHandler: ^(Object output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var DomainFlowApi = require('domain_flow_api');
var defaultClient = DomainFlowApi.ApiClient.instance;

// Configure API key authorization: cookieAuth
var cookieAuth = defaultClient.authentications['cookieAuth'];
cookieAuth.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//cookieAuth.apiKeyPrefix['domainflow_session'] = "Token";

// Create an instance of the API class
var api = new DomainFlowApi.ServerSettingsApi()
var body = Object; // {Object} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.configUpdateServer(body, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class configUpdateServerExample
    {
        public void main()
        {
            // Configure API key authorization: cookieAuth
            Configuration.Default.ApiKey.Add("domainflow_session", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("domainflow_session", "Bearer");

            // Create an instance of the API class
            var apiInstance = new ServerSettingsApi();
            var body = Object;  // Object | 

            try {
                // Update server configuration
                Object result = apiInstance.configUpdateServer(body);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling ServerSettingsApi.configUpdateServer: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure API key authorization: cookieAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('domainflow_session', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('domainflow_session', 'Bearer');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\ServerSettingsApi();
$body = Object; // Object | 

try {
    $result = $api_instance->configUpdateServer($body);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling ServerSettingsApi->configUpdateServer: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::ServerSettingsApi;

# Configure API key authorization: cookieAuth
$WWW::OPenAPIClient::Configuration::api_key->{'domainflow_session'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'domainflow_session'} = "Bearer";

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::ServerSettingsApi->new();
my $body = WWW::OPenAPIClient::Object::Object->new(); # Object | 

eval {
    my $result = $api_instance->configUpdateServer(body => $body);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling ServerSettingsApi->configUpdateServer: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure API key authorization: cookieAuth
openapi_client.configuration.api_key['domainflow_session'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['domainflow_session'] = 'Bearer'

# Create an instance of the API class
api_instance = openapi_client.ServerSettingsApi()
body = Object # Object | 

try:
    # Update server configuration
    api_response = api_instance.config_update_server(body)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ServerSettingsApi->configUpdateServer: %s\n" % e)
extern crate ServerSettingsApi;

pub fn main() {
    let body = Object; // Object

    let mut context = ServerSettingsApi::Context::default();
    let result = client.configUpdateServer(body, &context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Body parameters
Name Description
body *

Responses

Name Type Format Description
Retry-After Integer Seconds to wait before retrying


configUpdateStealth

Update stealth configuration


/config/stealth

Usage and SDK Samples

curl -X PUT \
 \
 -H "Accept: application/json" \
 -H "Content-Type: application/json" \
 "https://api.domainflow.dev/api/v2/config/stealth" \
 -d ''
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.ServerSettingsApi;

import java.io.File;
import java.util.*;

public class ServerSettingsApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure API key authorization: cookieAuth
        ApiKeyAuth cookieAuth = (ApiKeyAuth) defaultClient.getAuthentication("cookieAuth");
        cookieAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //cookieAuth.setApiKeyPrefix("Token");

        // Create an instance of the API class
        ServerSettingsApi apiInstance = new ServerSettingsApi();
        ConfigGetStealth200ResponseAllOfData configGetStealth200ResponseAllOfData = ; // ConfigGetStealth200ResponseAllOfData | 

        try {
            config_get_stealth_200_response result = apiInstance.configUpdateStealth(configGetStealth200ResponseAllOfData);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ServerSettingsApi#configUpdateStealth");
            e.printStackTrace();
        }
    }
}
import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final ConfigGetStealth200ResponseAllOfData configGetStealth200ResponseAllOfData = new ConfigGetStealth200ResponseAllOfData(); // ConfigGetStealth200ResponseAllOfData | 

try {
    final result = await api_instance.configUpdateStealth(configGetStealth200ResponseAllOfData);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->configUpdateStealth: $e\n');
}

import org.openapitools.client.api.ServerSettingsApi;

public class ServerSettingsApiExample {
    public static void main(String[] args) {
        ServerSettingsApi apiInstance = new ServerSettingsApi();
        ConfigGetStealth200ResponseAllOfData configGetStealth200ResponseAllOfData = ; // ConfigGetStealth200ResponseAllOfData | 

        try {
            config_get_stealth_200_response result = apiInstance.configUpdateStealth(configGetStealth200ResponseAllOfData);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ServerSettingsApi#configUpdateStealth");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: cookieAuth)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"domainflow_session"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"domainflow_session"];


// Create an instance of the API class
ServerSettingsApi *apiInstance = [[ServerSettingsApi alloc] init];
ConfigGetStealth200ResponseAllOfData *configGetStealth200ResponseAllOfData = ; // 

// Update stealth configuration
[apiInstance configUpdateStealthWith:configGetStealth200ResponseAllOfData
              completionHandler: ^(config_get_stealth_200_response output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var DomainFlowApi = require('domain_flow_api');
var defaultClient = DomainFlowApi.ApiClient.instance;

// Configure API key authorization: cookieAuth
var cookieAuth = defaultClient.authentications['cookieAuth'];
cookieAuth.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//cookieAuth.apiKeyPrefix['domainflow_session'] = "Token";

// Create an instance of the API class
var api = new DomainFlowApi.ServerSettingsApi()
var configGetStealth200ResponseAllOfData = ; // {ConfigGetStealth200ResponseAllOfData} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.configUpdateStealth(configGetStealth200ResponseAllOfData, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class configUpdateStealthExample
    {
        public void main()
        {
            // Configure API key authorization: cookieAuth
            Configuration.Default.ApiKey.Add("domainflow_session", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("domainflow_session", "Bearer");

            // Create an instance of the API class
            var apiInstance = new ServerSettingsApi();
            var configGetStealth200ResponseAllOfData = new ConfigGetStealth200ResponseAllOfData(); // ConfigGetStealth200ResponseAllOfData | 

            try {
                // Update stealth configuration
                config_get_stealth_200_response result = apiInstance.configUpdateStealth(configGetStealth200ResponseAllOfData);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling ServerSettingsApi.configUpdateStealth: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure API key authorization: cookieAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('domainflow_session', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('domainflow_session', 'Bearer');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\ServerSettingsApi();
$configGetStealth200ResponseAllOfData = ; // ConfigGetStealth200ResponseAllOfData | 

try {
    $result = $api_instance->configUpdateStealth($configGetStealth200ResponseAllOfData);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling ServerSettingsApi->configUpdateStealth: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::ServerSettingsApi;

# Configure API key authorization: cookieAuth
$WWW::OPenAPIClient::Configuration::api_key->{'domainflow_session'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'domainflow_session'} = "Bearer";

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::ServerSettingsApi->new();
my $configGetStealth200ResponseAllOfData = WWW::OPenAPIClient::Object::ConfigGetStealth200ResponseAllOfData->new(); # ConfigGetStealth200ResponseAllOfData | 

eval {
    my $result = $api_instance->configUpdateStealth(configGetStealth200ResponseAllOfData => $configGetStealth200ResponseAllOfData);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling ServerSettingsApi->configUpdateStealth: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure API key authorization: cookieAuth
openapi_client.configuration.api_key['domainflow_session'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['domainflow_session'] = 'Bearer'

# Create an instance of the API class
api_instance = openapi_client.ServerSettingsApi()
configGetStealth200ResponseAllOfData =  # ConfigGetStealth200ResponseAllOfData | 

try:
    # Update stealth configuration
    api_response = api_instance.config_update_stealth(configGetStealth200ResponseAllOfData)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ServerSettingsApi->configUpdateStealth: %s\n" % e)
extern crate ServerSettingsApi;

pub fn main() {
    let configGetStealth200ResponseAllOfData = ; // ConfigGetStealth200ResponseAllOfData

    let mut context = ServerSettingsApi::Context::default();
    let result = client.configUpdateStealth(configGetStealth200ResponseAllOfData, &context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Body parameters
Name Description
configGetStealth200ResponseAllOfData *

Responses


configUpdateWorker

Update worker configuration


/config/worker

Usage and SDK Samples

curl -X PUT \
 \
 -H "Accept: application/json" \
 -H "Content-Type: application/json" \
 "https://api.domainflow.dev/api/v2/config/worker" \
 -d ''
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.ServerSettingsApi;

import java.io.File;
import java.util.*;

public class ServerSettingsApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure API key authorization: cookieAuth
        ApiKeyAuth cookieAuth = (ApiKeyAuth) defaultClient.getAuthentication("cookieAuth");
        cookieAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //cookieAuth.setApiKeyPrefix("Token");

        // Create an instance of the API class
        ServerSettingsApi apiInstance = new ServerSettingsApi();
        map[String, oas_any_type_not_mapped] requestBody = Object; // map[String, oas_any_type_not_mapped] | 

        try {
            config_get_worker_200_response result = apiInstance.configUpdateWorker(requestBody);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ServerSettingsApi#configUpdateWorker");
            e.printStackTrace();
        }
    }
}
import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final map[String, oas_any_type_not_mapped] requestBody = new map[String, oas_any_type_not_mapped](); // map[String, oas_any_type_not_mapped] | 

try {
    final result = await api_instance.configUpdateWorker(requestBody);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->configUpdateWorker: $e\n');
}

import org.openapitools.client.api.ServerSettingsApi;

public class ServerSettingsApiExample {
    public static void main(String[] args) {
        ServerSettingsApi apiInstance = new ServerSettingsApi();
        map[String, oas_any_type_not_mapped] requestBody = Object; // map[String, oas_any_type_not_mapped] | 

        try {
            config_get_worker_200_response result = apiInstance.configUpdateWorker(requestBody);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ServerSettingsApi#configUpdateWorker");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: cookieAuth)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"domainflow_session"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"domainflow_session"];


// Create an instance of the API class
ServerSettingsApi *apiInstance = [[ServerSettingsApi alloc] init];
map[String, oas_any_type_not_mapped] *requestBody = Object; // 

// Update worker configuration
[apiInstance configUpdateWorkerWith:requestBody
              completionHandler: ^(config_get_worker_200_response output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var DomainFlowApi = require('domain_flow_api');
var defaultClient = DomainFlowApi.ApiClient.instance;

// Configure API key authorization: cookieAuth
var cookieAuth = defaultClient.authentications['cookieAuth'];
cookieAuth.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//cookieAuth.apiKeyPrefix['domainflow_session'] = "Token";

// Create an instance of the API class
var api = new DomainFlowApi.ServerSettingsApi()
var requestBody = Object; // {map[String, oas_any_type_not_mapped]} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.configUpdateWorker(requestBody, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class configUpdateWorkerExample
    {
        public void main()
        {
            // Configure API key authorization: cookieAuth
            Configuration.Default.ApiKey.Add("domainflow_session", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("domainflow_session", "Bearer");

            // Create an instance of the API class
            var apiInstance = new ServerSettingsApi();
            var requestBody = new map[String, oas_any_type_not_mapped](); // map[String, oas_any_type_not_mapped] | 

            try {
                // Update worker configuration
                config_get_worker_200_response result = apiInstance.configUpdateWorker(requestBody);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling ServerSettingsApi.configUpdateWorker: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure API key authorization: cookieAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('domainflow_session', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('domainflow_session', 'Bearer');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\ServerSettingsApi();
$requestBody = Object; // map[String, oas_any_type_not_mapped] | 

try {
    $result = $api_instance->configUpdateWorker($requestBody);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling ServerSettingsApi->configUpdateWorker: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::ServerSettingsApi;

# Configure API key authorization: cookieAuth
$WWW::OPenAPIClient::Configuration::api_key->{'domainflow_session'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'domainflow_session'} = "Bearer";

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::ServerSettingsApi->new();
my $requestBody = WWW::OPenAPIClient::Object::map[String, oas_any_type_not_mapped]->new(); # map[String, oas_any_type_not_mapped] | 

eval {
    my $result = $api_instance->configUpdateWorker(requestBody => $requestBody);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling ServerSettingsApi->configUpdateWorker: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure API key authorization: cookieAuth
openapi_client.configuration.api_key['domainflow_session'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['domainflow_session'] = 'Bearer'

# Create an instance of the API class
api_instance = openapi_client.ServerSettingsApi()
requestBody = Object # map[String, oas_any_type_not_mapped] | 

try:
    # Update worker configuration
    api_response = api_instance.config_update_worker(requestBody)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ServerSettingsApi->configUpdateWorker: %s\n" % e)
extern crate ServerSettingsApi;

pub fn main() {
    let requestBody = Object; // map[String, oas_any_type_not_mapped]

    let mut context = ServerSettingsApi::Context::default();
    let result = client.configUpdateWorker(requestBody, &context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Body parameters
Name Description
requestBody *

Responses

Name Type Format Description
Retry-After Integer Seconds to wait before retrying


Sse

sseEventsAll

Stream campaign events


/sse/events

Usage and SDK Samples

curl -X GET \
 \
 -H "Accept: text/event-stream,application/json" \
 "https://api.domainflow.dev/api/v2/sse/events"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.SseApi;

import java.io.File;
import java.util.*;

public class SseApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure API key authorization: cookieAuth
        ApiKeyAuth cookieAuth = (ApiKeyAuth) defaultClient.getAuthentication("cookieAuth");
        cookieAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //cookieAuth.setApiKeyPrefix("Token");

        // Create an instance of the API class
        SseApi apiInstance = new SseApi();

        try {
            'String' result = apiInstance.sseEventsAll();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling SseApi#sseEventsAll");
            e.printStackTrace();
        }
    }
}
import 'package:openapi/api.dart';

final api_instance = DefaultApi();


try {
    final result = await api_instance.sseEventsAll();
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->sseEventsAll: $e\n');
}

import org.openapitools.client.api.SseApi;

public class SseApiExample {
    public static void main(String[] args) {
        SseApi apiInstance = new SseApi();

        try {
            'String' result = apiInstance.sseEventsAll();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling SseApi#sseEventsAll");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: cookieAuth)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"domainflow_session"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"domainflow_session"];


// Create an instance of the API class
SseApi *apiInstance = [[SseApi alloc] init];

// Stream campaign events
[apiInstance sseEventsAllWithCompletionHandler: 
              ^('String' output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var DomainFlowApi = require('domain_flow_api');
var defaultClient = DomainFlowApi.ApiClient.instance;

// Configure API key authorization: cookieAuth
var cookieAuth = defaultClient.authentications['cookieAuth'];
cookieAuth.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//cookieAuth.apiKeyPrefix['domainflow_session'] = "Token";

// Create an instance of the API class
var api = new DomainFlowApi.SseApi()
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.sseEventsAll(callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class sseEventsAllExample
    {
        public void main()
        {
            // Configure API key authorization: cookieAuth
            Configuration.Default.ApiKey.Add("domainflow_session", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("domainflow_session", "Bearer");

            // Create an instance of the API class
            var apiInstance = new SseApi();

            try {
                // Stream campaign events
                'String' result = apiInstance.sseEventsAll();
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling SseApi.sseEventsAll: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure API key authorization: cookieAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('domainflow_session', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('domainflow_session', 'Bearer');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\SseApi();

try {
    $result = $api_instance->sseEventsAll();
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling SseApi->sseEventsAll: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::SseApi;

# Configure API key authorization: cookieAuth
$WWW::OPenAPIClient::Configuration::api_key->{'domainflow_session'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'domainflow_session'} = "Bearer";

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::SseApi->new();

eval {
    my $result = $api_instance->sseEventsAll();
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling SseApi->sseEventsAll: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure API key authorization: cookieAuth
openapi_client.configuration.api_key['domainflow_session'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['domainflow_session'] = 'Bearer'

# Create an instance of the API class
api_instance = openapi_client.SseApi()

try:
    # Stream campaign events
    api_response = api_instance.sse_events_all()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling SseApi->sseEventsAll: %s\n" % e)
extern crate SseApi;

pub fn main() {

    let mut context = SseApi::Context::default();
    let result = client.sseEventsAll(&context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Responses

Name Type Format Description
Retry-After Integer Seconds to wait before retrying


sseEventsCampaign

Stream campaign events (specific campaign)


/sse/campaigns/{campaignId}/events

Usage and SDK Samples

curl -X GET \
 \
 -H "Accept: text/event-stream,application/json" \
 "https://api.domainflow.dev/api/v2/sse/campaigns/{campaignId}/events"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.SseApi;

import java.io.File;
import java.util.*;

public class SseApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure API key authorization: cookieAuth
        ApiKeyAuth cookieAuth = (ApiKeyAuth) defaultClient.getAuthentication("cookieAuth");
        cookieAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //cookieAuth.setApiKeyPrefix("Token");

        // Create an instance of the API class
        SseApi apiInstance = new SseApi();
        UUID campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 

        try {
            'String' result = apiInstance.sseEventsCampaign(campaignId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling SseApi#sseEventsCampaign");
            e.printStackTrace();
        }
    }
}
import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final UUID campaignId = new UUID(); // UUID | 

try {
    final result = await api_instance.sseEventsCampaign(campaignId);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->sseEventsCampaign: $e\n');
}

import org.openapitools.client.api.SseApi;

public class SseApiExample {
    public static void main(String[] args) {
        SseApi apiInstance = new SseApi();
        UUID campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 

        try {
            'String' result = apiInstance.sseEventsCampaign(campaignId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling SseApi#sseEventsCampaign");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: cookieAuth)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"domainflow_session"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"domainflow_session"];


// Create an instance of the API class
SseApi *apiInstance = [[SseApi alloc] init];
UUID *campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; //  (default to null)

// Stream campaign events (specific campaign)
[apiInstance sseEventsCampaignWith:campaignId
              completionHandler: ^('String' output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var DomainFlowApi = require('domain_flow_api');
var defaultClient = DomainFlowApi.ApiClient.instance;

// Configure API key authorization: cookieAuth
var cookieAuth = defaultClient.authentications['cookieAuth'];
cookieAuth.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//cookieAuth.apiKeyPrefix['domainflow_session'] = "Token";

// Create an instance of the API class
var api = new DomainFlowApi.SseApi()
var campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // {UUID} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.sseEventsCampaign(campaignId, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class sseEventsCampaignExample
    {
        public void main()
        {
            // Configure API key authorization: cookieAuth
            Configuration.Default.ApiKey.Add("domainflow_session", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("domainflow_session", "Bearer");

            // Create an instance of the API class
            var apiInstance = new SseApi();
            var campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d;  // UUID |  (default to null)

            try {
                // Stream campaign events (specific campaign)
                'String' result = apiInstance.sseEventsCampaign(campaignId);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling SseApi.sseEventsCampaign: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure API key authorization: cookieAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('domainflow_session', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('domainflow_session', 'Bearer');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\SseApi();
$campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 

try {
    $result = $api_instance->sseEventsCampaign($campaignId);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling SseApi->sseEventsCampaign: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::SseApi;

# Configure API key authorization: cookieAuth
$WWW::OPenAPIClient::Configuration::api_key->{'domainflow_session'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'domainflow_session'} = "Bearer";

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::SseApi->new();
my $campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; # UUID | 

eval {
    my $result = $api_instance->sseEventsCampaign(campaignId => $campaignId);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling SseApi->sseEventsCampaign: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure API key authorization: cookieAuth
openapi_client.configuration.api_key['domainflow_session'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['domainflow_session'] = 'Bearer'

# Create an instance of the API class
api_instance = openapi_client.SseApi()
campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d # UUID |  (default to null)

try:
    # Stream campaign events (specific campaign)
    api_response = api_instance.sse_events_campaign(campaignId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling SseApi->sseEventsCampaign: %s\n" % e)
extern crate SseApi;

pub fn main() {
    let campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID

    let mut context = SseApi::Context::default();
    let result = client.sseEventsCampaign(campaignId, &context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Path parameters
Name Description
campaignId*
UUID (uuid)
Required

Responses

Name Type Format Description
Retry-After Integer Seconds to wait before retrying


sseEventsStats

Get SSE connection statistics


/sse/events/stats

Usage and SDK Samples

curl -X GET \
 \
 -H "Accept: application/json" \
 "https://api.domainflow.dev/api/v2/sse/events/stats"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.SseApi;

import java.io.File;
import java.util.*;

public class SseApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure API key authorization: cookieAuth
        ApiKeyAuth cookieAuth = (ApiKeyAuth) defaultClient.getAuthentication("cookieAuth");
        cookieAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //cookieAuth.setApiKeyPrefix("Token");

        // Create an instance of the API class
        SseApi apiInstance = new SseApi();

        try {
            sse_events_stats_200_response result = apiInstance.sseEventsStats();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling SseApi#sseEventsStats");
            e.printStackTrace();
        }
    }
}
import 'package:openapi/api.dart';

final api_instance = DefaultApi();


try {
    final result = await api_instance.sseEventsStats();
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->sseEventsStats: $e\n');
}

import org.openapitools.client.api.SseApi;

public class SseApiExample {
    public static void main(String[] args) {
        SseApi apiInstance = new SseApi();

        try {
            sse_events_stats_200_response result = apiInstance.sseEventsStats();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling SseApi#sseEventsStats");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: cookieAuth)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"domainflow_session"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"domainflow_session"];


// Create an instance of the API class
SseApi *apiInstance = [[SseApi alloc] init];

// Get SSE connection statistics
[apiInstance sseEventsStatsWithCompletionHandler: 
              ^(sse_events_stats_200_response output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var DomainFlowApi = require('domain_flow_api');
var defaultClient = DomainFlowApi.ApiClient.instance;

// Configure API key authorization: cookieAuth
var cookieAuth = defaultClient.authentications['cookieAuth'];
cookieAuth.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//cookieAuth.apiKeyPrefix['domainflow_session'] = "Token";

// Create an instance of the API class
var api = new DomainFlowApi.SseApi()
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.sseEventsStats(callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class sseEventsStatsExample
    {
        public void main()
        {
            // Configure API key authorization: cookieAuth
            Configuration.Default.ApiKey.Add("domainflow_session", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("domainflow_session", "Bearer");

            // Create an instance of the API class
            var apiInstance = new SseApi();

            try {
                // Get SSE connection statistics
                sse_events_stats_200_response result = apiInstance.sseEventsStats();
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling SseApi.sseEventsStats: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure API key authorization: cookieAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('domainflow_session', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('domainflow_session', 'Bearer');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\SseApi();

try {
    $result = $api_instance->sseEventsStats();
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling SseApi->sseEventsStats: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::SseApi;

# Configure API key authorization: cookieAuth
$WWW::OPenAPIClient::Configuration::api_key->{'domainflow_session'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'domainflow_session'} = "Bearer";

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::SseApi->new();

eval {
    my $result = $api_instance->sseEventsStats();
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling SseApi->sseEventsStats: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure API key authorization: cookieAuth
openapi_client.configuration.api_key['domainflow_session'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['domainflow_session'] = 'Bearer'

# Create an instance of the API class
api_instance = openapi_client.SseApi()

try:
    # Get SSE connection statistics
    api_response = api_instance.sse_events_stats()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling SseApi->sseEventsStats: %s\n" % e)
extern crate SseApi;

pub fn main() {

    let mut context = SseApi::Context::default();
    let result = client.sseEventsStats(&context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Responses

Name Type Format Description
Retry-After Integer Seconds to wait before retrying